@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/index-C-FYUuFG.d.ts

@@ -0,0 +1,193 @@
+import { D as AgentCandidateExecutionPhaseResult, O as AgentCandidateExecutionRecoveryEvidence, T as AgentCandidateExecutionLease, _ as AgentCandidateExecutionAttemptRecord, b as AgentCandidateExecutionClaimResult, j as AgentCandidateExecutionTerminalResult, k as AgentCandidateExecutionStageResult, v as AgentCandidateExecutionAttemptRef, w as AgentCandidateExecutionFinishResult, x as AgentCandidateExecutionClaimStore, y as AgentCandidateExecutionClaim } from "./protected-model-port-BP6Z4eau.js";
+import { B as VerifiedAgentCandidate, O as AgentCandidateVerificationPorts, P as PreparedAgentCandidateExecution, a as AgentCandidateExecutionPorts, b as AgentCandidateOutputPurpose, c as AgentCandidateExecutorPort, k as AgentCandidateWorkspacePort, p as AgentCandidateExecutorWorkspaceFile, y as AgentCandidateOutputArtifactPort } from "./types-BaIpb0XT.js";
+import { TraceStore } from "@tangle-network/agent-eval";
+import { CodeSurface } from "@tangle-network/agent-eval/campaign";
+import { AgentCandidateArtifactRef, AgentCandidateBundle, AgentCandidateCapturedArtifact, AgentCandidateCodeDisabled, AgentCandidateCodeNoOp, AgentCandidateExecution, AgentCandidateGitHubRepository, AgentCandidateKnowledge, AgentCandidateMemoryPolicy, AgentCandidateProfile, AgentCandidateRunCell, AgentCandidateWorkspaceSnapshotEvidence, AgentProfile as AgentProfile$1, AgentProfileDiff, Sha256Digest } from "@tangle-network/agent-interface";
+import { AgentEnvironmentProvider, AgentExactProcessResources } from "@tangle-network/agent-interface/environment-provider";
+//#region src/candidate-execution/bundle.d.ts
+/** Exact candidate wire shape before the runtime computes its canonical digest. */
+type AgentCandidateBundleInput = Omit<AgentCandidateBundle, 'digest'>;
+/** Validate and content-address a candidate bundle before it crosses an approval boundary. */
+declare function sealAgentCandidateBundle(input: AgentCandidateBundleInput): AgentCandidateBundle;
+//#endregion
+//#region src/candidate-execution/builder.d.ts
+/** A complete profile that can be frozen without losing behavior. */
+type AgentCandidateProfileSource = {
+  kind: 'profile';
+  profile: AgentProfile$1;
+} | {
+  kind: 'profile-diffs';
+  base: AgentProfile$1;
+  /** Applied in order before the resulting profile is frozen into the bundle. */
+  diffs: readonly AgentProfileDiff[];
+} | {
+  kind: 'candidate-profile';
+  /** Already converted to the closed, secret-free candidate profile contract. */
+  profile: AgentCandidateProfile;
+};
+/** The only accepted path from an agent-eval code candidate to executable bytes. */
+interface AgentCandidateCodeSurfaceSource {
+  kind: 'code-surface';
+  surface: CodeSurface;
+  repository: AgentCandidateGitHubRepository;
+  /** Optional parent directory used to resolve a relative `surface.worktreeRef`. */
+  worktreeDir?: string;
+}
+/** Explicit control/no-op code or one finalized CodeSurface whose bytes must still verify. */
+type AgentCandidateCodeSource = AgentCandidateCodeDisabled | AgentCandidateCodeNoOp | AgentCandidateCodeSurfaceSource;
+/** Complete measured surfaces and execution policy compiled into one candidate bundle. */
+interface BuildAgentCandidateBundleInput {
+  profile: AgentCandidateProfileSource;
+  code: AgentCandidateCodeSource;
+  execution: AgentCandidateExecution;
+  knowledge?: AgentCandidateKnowledge;
+  memory: AgentCandidateMemoryPolicy;
+}
+/**
+ * Compile one measured profile/code candidate into the immutable execution
+ * contract. Code bytes are re-read and verified by agent-eval before they are
+ * embedded. The returned bundle is schema-validated, canonically digested, and
+ * deeply immutable; call `verifyAgentCandidateBundle` at the execution boundary
+ * to re-read external memory, repository, and workspace artifacts.
+ */
+declare function buildAgentCandidateBundle(input: BuildAgentCandidateBundleInput): ReturnType<typeof sealAgentCandidateBundle>;
+//#endregion
+//#region src/candidate-execution/claim-file-store.d.ts
+interface FileAgentCandidateExecutionClaimStoreOptions {
+  /** Evaluator-owned directory shared by every process allowed to execute candidates. */
+  directory: string;
+  /** Testable evaluator clock; defaults to `Date.now`. */
+  now?: () => number;
+}
+/** Cross-process lifecycle implemented as fsynced, create-if-absent records. */
+declare class FileAgentCandidateExecutionClaimStore implements AgentCandidateExecutionClaimStore {
+  private readonly directory;
+  private readonly now;
+  constructor(options: FileAgentCandidateExecutionClaimStoreOptions);
+  tryClaim(requested: AgentCandidateExecutionClaim): Promise<AgentCandidateExecutionClaimResult>;
+  getAttempt(requestedAttempt: AgentCandidateExecutionAttemptRef): Promise<AgentCandidateExecutionAttemptRecord | undefined>;
+  markCandidateMayRun(requestedLease: AgentCandidateExecutionLease): Promise<AgentCandidateExecutionPhaseResult>;
+  stageTerminal(requestedLease: AgentCandidateExecutionLease, result: AgentCandidateExecutionTerminalResult): Promise<AgentCandidateExecutionStageResult>;
+  finish(requestedLease: AgentCandidateExecutionLease, requestedTerminalDigest: Sha256Digest): Promise<AgentCandidateExecutionFinishResult>;
+  recoverExpired(requestedAttempt: AgentCandidateExecutionAttemptRef, evidence: AgentCandidateExecutionRecoveryEvidence): Promise<AgentCandidateExecutionFinishResult>;
+  private storedAttempt;
+  private transitionState;
+  private retryFailure;
+  private ownerPublication;
+  private claimPath;
+  private terminalPath;
+  private transitionPath;
+}
+//#endregion
+//#region src/candidate-execution/dispose.d.ts
+interface DisposePreparedAgentCandidateOptions {
+  cleanupTimeoutMs?: number;
+}
+/** Revoke reservations held by a prepared candidate that will not be executed. */
+declare function disposePreparedAgentCandidateExecution(prepared: PreparedAgentCandidateExecution, options?: DisposePreparedAgentCandidateOptions): Promise<{
+  disposed: true;
+}>;
+//#endregion
+//#region src/candidate-execution/exact-process-executor.d.ts
+interface ExactProcessCandidateExecutorOptions {
+  provider: AgentEnvironmentProvider;
+  resources: AgentExactProcessResources;
+  provisionTimeoutMs?: number;
+  recoveryRetentionMs?: number;
+  providerOptions?: Record<string, unknown>;
+}
+/** Adapt one neutral exact-process provider to Runtime's trusted candidate boundary. */
+declare function exactProcessProviderAsCandidateExecutor(options: ExactProcessCandidateExecutorOptions): AgentCandidateExecutorPort;
+//#endregion
+//#region src/candidate-execution/knowledge.d.ts
+/** Environment variable containing the materialized candidate knowledge root. */
+declare const CANDIDATE_KNOWLEDGE_ROOT_ENV = "TANGLE_CANDIDATE_KNOWLEDGE_ROOT";
+/** Environment variable containing the materialized retrieval configuration path. */
+declare const CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV = "TANGLE_CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG";
+/** Deterministic, signed locations used by every candidate executor. */
+declare function candidateKnowledgeExecutionPaths(taskRoot: string, hasRetrievalConfig: boolean): {
+  root: string;
+  retrievalConfig?: string;
+};
+//#endregion
+//#region src/candidate-execution/output-artifacts.d.ts
+/** Persist evaluator evidence, read it back, and bind the returned locator to the exact bytes. */
+declare function persistCandidateOutputArtifact(port: AgentCandidateOutputArtifactPort, input: {
+  executionId: string;
+  purpose: AgentCandidateOutputPurpose;
+  bytes: Uint8Array;
+  signal?: AbortSignal;
+}): Promise<AgentCandidateArtifactRef>;
+//#endregion
+//#region src/candidate-execution/recover.d.ts
+interface RecoverExpiredAgentCandidateOptions {
+  attempt: AgentCandidateExecutionAttemptRef;
+  claimStore: AgentCandidateExecutionClaimStore;
+  executor: AgentCandidateExecutorPort;
+  traceStore: TraceStore;
+  ports: Pick<AgentCandidateExecutionPorts, 'models' | 'memory'>;
+  outputArtifacts: AgentCandidateOutputArtifactPort;
+  cleanupTimeoutMs?: number;
+  /** Evaluator clock; must be the same clock used by the claim store. */
+  now?: () => number;
+}
+/** Close an expired crashed attempt from persisted non-secret handles, then record failure. */
+declare function recoverExpiredAgentCandidateExecution(options: RecoverExpiredAgentCandidateOptions): Promise<AgentCandidateExecutionFinishResult>;
+//#endregion
+//#region src/candidate-execution/verify.d.ts
+/** Surfaces admitted by Runtime's verifier before an environment adapter is selected. */
+declare const AGENT_CANDIDATE_EXECUTION_SUPPORT: Readonly<{
+  outcomes: readonly ["workspace", "output"];
+  code: readonly ["disabled", "no-op", "git-patch"];
+  memory: readonly ["disabled", "isolated"];
+  knowledge: true;
+  profile: Readonly<{
+    mcpTransports: readonly ["stdio"];
+    remoteMcp: false;
+    tools: false;
+    permissions: false;
+    modes: false;
+    confidential: false;
+  }>;
+}>;
+/** Verifies every digest, resource, workspace, and Git object in a candidate bundle. */
+declare function verifyAgentCandidateBundle(input: unknown, ports: AgentCandidateVerificationPorts): Promise<VerifiedAgentCandidate>;
+//#endregion
+//#region src/candidate-execution/workspace-archive.d.ts
+interface AgentCandidateWorkspaceArchiveLimits {
+  maxArchiveBytes: number;
+  maxEmbeddedArtifactBytes: number;
+  maxFiles: number;
+  maxFileBytes: number;
+  maxTotalFileBytes: number;
+  maxPathBytes: number;
+  maxRepositoryBundleBytes: number;
+}
+interface CaptureAgentCandidateWorkspaceOptions {
+  /** Include Git HEAD so task preparation can prove its exact commit and tree. */
+  includeRepository?: boolean;
+  limits?: Partial<AgentCandidateWorkspaceArchiveLimits>;
+  /** Use the evaluator-owned artifact store when manifest or archive bytes should not be embedded. */
+  artifactPersistence?: {
+    executionId: string;
+    outputArtifacts: AgentCandidateOutputArtifactPort;
+    signal?: AbortSignal;
+  };
+}
+interface CreateAgentCandidateWorkspacePortOptions {
+  limits?: Partial<AgentCandidateWorkspaceArchiveLimits>;
+}
+interface CapturedAgentCandidateWorkspace {
+  readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
+  /** Caller-owned bytes accepted by createAgentCandidateWorkspacePort. */
+  readonly archive: Uint8Array;
+}
+/** Capture one exact regular-file workspace for immutable candidate execution. */
+declare function captureAgentCandidateWorkspace(rootInput: string, options?: CaptureAgentCandidateWorkspaceOptions): Promise<CapturedAgentCandidateWorkspace>;
+/** Capture detached files returned by a remote executor into the standard archive. */
+declare function captureAgentCandidateWorkspaceFiles(input: readonly AgentCandidateExecutorWorkspaceFile[], options?: Omit<CaptureAgentCandidateWorkspaceOptions, 'includeRepository'>): Promise<CapturedAgentCandidateWorkspace>;
+/** Create the standard bounded materializer for candidate execution ports. */
+declare function createAgentCandidateWorkspacePort(options?: CreateAgentCandidateWorkspacePortOptions): AgentCandidateWorkspacePort;
+//#endregion
+export { AgentCandidateCodeSurfaceSource as C, AgentCandidateBundleInput as D, buildAgentCandidateBundle as E, sealAgentCandidateBundle as O, AgentCandidateCodeSource as S, BuildAgentCandidateBundleInput as T, exactProcessProviderAsCandidateExecutor as _, captureAgentCandidateWorkspace as a, FileAgentCandidateExecutionClaimStore as b, AGENT_CANDIDATE_EXECUTION_SUPPORT as c, recoverExpiredAgentCandidateExecution as d, persistCandidateOutputArtifact as f, ExactProcessCandidateExecutorOptions as g, candidateKnowledgeExecutionPaths as h, CreateAgentCandidateWorkspacePortOptions as i, verifyAgentCandidateBundle as l, CANDIDATE_KNOWLEDGE_ROOT_ENV as m, CaptureAgentCandidateWorkspaceOptions as n, captureAgentCandidateWorkspaceFiles as o, CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV as p, CapturedAgentCandidateWorkspace as r, createAgentCandidateWorkspacePort as s, AgentCandidateWorkspaceArchiveLimits as t, RecoverExpiredAgentCandidateOptions as u, DisposePreparedAgentCandidateOptions as v, AgentCandidateProfileSource as w, FileAgentCandidateExecutionClaimStoreOptions as x, disposePreparedAgentCandidateExecution as y };
+//# sourceMappingURL=index-C-FYUuFG.d.ts.map

package/dist/index-CbNM40xG.d.ts

@@ -0,0 +1,140 @@
+import { R as Budget, st as SupervisedResult } from "./environment-provider-IUGU3epE.js";
+import { Ec as DeliverableSpec, ct as SupervisorProfile, j as SuperviseOptions, qs as ExecutorConfig } from "./index-DruSKs3Z.js";
+import { y as AgentCandidateOutputArtifactPort } from "./types-BaIpb0XT.js";
+import { i as AgentImprovementActivationTransition, n as AgentImprovementActivationResultStore, t as AgentImprovementActivationReconciliation } from "./activation-DyWB0K6E.js";
+import { AgentCandidateBundle, AgentCandidateCapturedArtifact, AgentCandidateKnowledge } from "@tangle-network/agent-interface";
+import { BuildEvalKnowledgeBundleOptions, KnowledgeBaseQualityOptions, KnowledgeImprovementOptions, KnowledgeImprovementResult, KnowledgeReadinessSpec, PromoteKnowledgeCandidateOptions, RagKnowledgeUpdateResult } from "@tangle-network/agent-knowledge";
+//#region src/knowledge/activation.d.ts
+interface CreateKnowledgeImprovementActivationExecutorOptions extends Omit<PromoteKnowledgeCandidateOptions, 'root' | 'candidate'> {
+  root: string;
+  identity: string;
+  results: AgentImprovementActivationResultStore;
+}
+interface KnowledgeImprovementActivationExecutor {
+  transition: AgentImprovementActivationTransition;
+  reconcile: AgentImprovementActivationReconciliation;
+}
+/** Apply or restore one local knowledge candidate through the shared activation contract. */
+declare function createKnowledgeImprovementActivationExecutor(options: CreateKnowledgeImprovementActivationExecutorOptions): KnowledgeImprovementActivationExecutor;
+//#endregion
+//#region src/knowledge/supervised-update.d.ts
+/** Standing prompt for a supervisor that grows a shared knowledge base through spawned researchers. */
+declare const RESEARCH_SUPERVISOR_SYSTEM_PROMPT: string;
+interface KnowledgeReadinessCheckInput {
+  root: string;
+  goal: string;
+  readinessSpecs?: readonly unknown[];
+  readinessTaskId?: string;
+  readiness?: unknown;
+}
+type KnowledgeReadinessCheckResult = boolean | {
+  ready: boolean;
+  summary?: string;
+  metadata?: Record<string, unknown>;
+};
+type KnowledgeReadinessCheck = (input: KnowledgeReadinessCheckInput) => Promise<KnowledgeReadinessCheckResult> | KnowledgeReadinessCheckResult;
+interface SupervisedKnowledgeUpdateInput {
+  goal?: string;
+  root?: string;
+  candidateRoot?: string;
+  findings?: readonly unknown[];
+  metadata?: Record<string, unknown>;
+}
+interface SupervisedKnowledgeUpdateResult {
+  applied: boolean;
+  summary: string;
+  supervised: SupervisedResult<unknown>;
+  metadata: NonNullable<RagKnowledgeUpdateResult['metadata']>;
+}
+interface SupervisedKnowledgeUpdateOptions {
+  root: string;
+  goal: string;
+  readiness: KnowledgeReadinessCheck;
+  readinessSpecs?: readonly unknown[];
+  readinessTaskId?: string;
+  readinessOptions?: unknown;
+  findings?: readonly unknown[];
+  metadata?: Record<string, unknown>;
+  budget: Budget;
+  backend?: ExecutorConfig;
+  makeWorkerAgent?: SuperviseOptions['makeWorkerAgent'];
+  harness?: string;
+  supervisorModel?: string;
+  supervisorSystemPrompt?: string;
+  superviseOptions?: Partial<Omit<SuperviseOptions, 'budget' | 'backend' | 'deliverable' | 'makeWorkerAgent' | 'allowedModels'>>;
+  allowedModels?: readonly string[];
+  runSupervised?: (profile: SupervisorProfile, task: unknown, opts: SuperviseOptions) => Promise<SupervisedResult<unknown>>;
+}
+type SupervisedKnowledgeUpdater = (input: SupervisedKnowledgeUpdateInput) => Promise<SupervisedKnowledgeUpdateResult>;
+/** Build the completion check a supervised KB update uses to stop only when the KB is ready. */
+declare function knowledgeReadinessDeliverable(options: Pick<SupervisedKnowledgeUpdateOptions, 'root' | 'goal' | 'readiness' | 'readinessSpecs' | 'readinessTaskId' | 'readinessOptions'>): DeliverableSpec<unknown>;
+/** Create an `improveKnowledgeBase` update callback backed by runtime supervision. */
+declare function createSupervisedKnowledgeUpdater(options: SupervisedKnowledgeUpdateOptions): SupervisedKnowledgeUpdater;
+/** Run a runtime supervisor that updates one candidate knowledge base and stops on readiness. */
+declare function runSupervisedKnowledgeUpdate(options: SupervisedKnowledgeUpdateOptions): Promise<SupervisedKnowledgeUpdateResult>;
+/** Format the supervisor task with the KB root, readiness requirements, current findings, and metadata. */
+declare function formatSupervisedKnowledgeTask(options: Pick<SupervisedKnowledgeUpdateOptions, 'root' | 'goal' | 'readinessSpecs' | 'readinessTaskId' | 'findings' | 'metadata'>): string;
+//#endregion
+//#region src/knowledge/improvement-job.d.ts
+interface RunKnowledgeImprovementJobOptions extends Omit<KnowledgeImprovementOptions, 'updateKnowledge'> {
+  budget: Budget;
+  readinessCheck?: KnowledgeReadinessCheck;
+  backend?: ExecutorConfig;
+  makeWorkerAgent?: SuperviseOptions['makeWorkerAgent'];
+  harness?: string;
+  supervisorModel?: string;
+  supervisorSystemPrompt?: string;
+  superviseOptions?: Partial<Omit<SuperviseOptions, 'budget' | 'backend' | 'deliverable' | 'makeWorkerAgent' | 'allowedModels'>>;
+  allowedModels?: readonly string[];
+  runSupervised?: (profile: SupervisorProfile, task: unknown, opts: SuperviseOptions) => Promise<SupervisedResult<unknown>>;
+  candidateArtifacts?: AgentCandidateOutputArtifactPort;
+  onMeasurement?: (measurement: KnowledgeImprovementJobMeasurement) => Promise<void> | void;
+}
+interface KnowledgeImprovementJobMeasurement {
+  startedAt: string;
+  finishedAt: string;
+  durationMs: number;
+  updateCalls: number;
+  updateDurationMs: number;
+  supervisedSpent: {
+    iterations: number;
+    inputTokens: number;
+    outputTokens: number;
+    usdKnown: boolean;
+    usd: number;
+    ms: number;
+  };
+}
+interface KnowledgeImprovementJobResult {
+  improvement: KnowledgeImprovementResult;
+  knowledge?: KnowledgeImprovementCandidatePair;
+  measurement: KnowledgeImprovementJobMeasurement;
+  blocked: boolean;
+}
+interface KnowledgeImprovementCandidatePair {
+  reference: AgentCandidateKnowledge['candidate'];
+  evaluation: AgentCandidateCapturedArtifact;
+  baseline: AgentCandidateKnowledge['snapshot'];
+  candidate: AgentCandidateKnowledge['snapshot'];
+}
+interface KnowledgeImprovementExperimentBundles {
+  baseline: AgentCandidateBundle;
+  candidate: AgentCandidateBundle;
+}
+interface AgentKnowledgeReadinessCheckOptions {
+  goal: string;
+  readinessSpecs?: readonly KnowledgeReadinessSpec[];
+  readinessTaskId?: string;
+  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
+  strict?: boolean;
+  kbQuality?: KnowledgeBaseQualityOptions;
+}
+/** Build the default readiness check backed by `@tangle-network/agent-knowledge` validation and scoring. */
+declare function createAgentKnowledgeReadinessCheck(options: AgentKnowledgeReadinessCheckOptions): KnowledgeReadinessCheck;
+/** Produce a frozen KB candidate while leaving live knowledge content unchanged. */
+declare function runKnowledgeImprovementJob(options: RunKnowledgeImprovementJobOptions): Promise<KnowledgeImprovementJobResult>;
+/** Attach both frozen knowledge inputs to one otherwise-identical bundle pair. */
+declare function buildKnowledgeImprovementExperimentBundles(bundle: AgentCandidateBundle, knowledge: KnowledgeImprovementCandidatePair): KnowledgeImprovementExperimentBundles;
+//#endregion
+export { KnowledgeImprovementActivationExecutor as C, CreateKnowledgeImprovementActivationExecutorOptions as S, SupervisedKnowledgeUpdater as _, KnowledgeImprovementJobResult as a, knowledgeReadinessDeliverable as b, createAgentKnowledgeReadinessCheck as c, KnowledgeReadinessCheckInput as d, KnowledgeReadinessCheckResult as f, SupervisedKnowledgeUpdateResult as g, SupervisedKnowledgeUpdateOptions as h, KnowledgeImprovementJobMeasurement as i, runKnowledgeImprovementJob as l, SupervisedKnowledgeUpdateInput as m, KnowledgeImprovementCandidatePair as n, RunKnowledgeImprovementJobOptions as o, RESEARCH_SUPERVISOR_SYSTEM_PROMPT as p, KnowledgeImprovementExperimentBundles as r, buildKnowledgeImprovementExperimentBundles as s, AgentKnowledgeReadinessCheckOptions as t, KnowledgeReadinessCheck as u, createSupervisedKnowledgeUpdater as v, createKnowledgeImprovementActivationExecutor as w, runSupervisedKnowledgeUpdate as x, formatSupervisedKnowledgeTask as y };
+//# sourceMappingURL=index-CbNM40xG.d.ts.map