@tangle-network/agent-runtime 0.36.0 → 0.38.0

package/dist/otel-export-CNmeg_7B.d.ts

@@ -0,0 +1,627 @@
+import { CoderOutput, CoderTask } from './profiles.js';
+import { L as LoopSandboxClient } from './types-CmkQl8qE.js';
+import { SandboxInstance } from '@tangle-network/sandbox';
+import { O as OpenAIChatTool } from './types-CsCCryln.js';
+
+/**
+ * @experimental
+ *
+ * Delegation executors — the layer between MCP delegates and the sandbox
+ * substrate. Each executor exposes a {@link LoopSandboxClient} the kernel
+ * consumes plus a placement tag so the trace pipeline can correlate workers
+ * with their physical placement.
+ *
+ * Two implementations ship in-box:
+ *
+ * - {@link createSiblingSandboxExecutor} — every delegation spawns a fresh
+ *   sandbox sibling to the caller. Default when the MCP server runs as a
+ *   standalone CLI mounted outside a fleet.
+ *
+ * - {@link createFleetWorkspaceExecutor} — delegations dispatch onto machines
+ *   in the caller's existing fleet so worker diffs land directly on the
+ *   caller's filesystem (the fleet's shared workspace). Selected when the
+ *   parent sandbox passes `TANGLE_FLEET_ID` into the MCP server's env.
+ */
+
+/** @experimental */
+interface DelegationExecutor {
+    /** Sandbox client the kernel calls. Returned with `describePlacement` set. */
+    readonly client: LoopSandboxClient;
+    /** Best-effort one-liner used in stderr boot logs and diagnostics. */
+    describe(): string;
+}
+/** @experimental */
+interface SiblingSandboxExecutorOptions {
+    client: LoopSandboxClient;
+}
+/**
+ * Wrap a raw sandbox SDK client so the kernel emits
+ * `loop.iteration.dispatch` events with `{ placement: 'sibling', sandboxId }`.
+ *
+ * The returned client `.create()` delegates to the underlying client; the
+ * only added behavior is a `describePlacement` tag the kernel reads.
+ *
+ * @experimental
+ */
+declare function createSiblingSandboxExecutor(options: SiblingSandboxExecutorOptions): DelegationExecutor;
+/**
+ * Minimal `SandboxFleet` surface the fleet executor calls. Declared
+ * structurally so tests can pass an in-memory stub without instantiating the
+ * sandbox SDK.
+ *
+ * @experimental
+ */
+interface FleetHandle {
+    readonly fleetId: string;
+    /** Machine ids in dispatch-eligible order. The executor round-robins. */
+    readonly ids: ReadonlyArray<string>;
+    /** Resolve a machine id to its `SandboxInstance` — that machine is mounted
+     * on the fleet's shared workspace, so any diff the worker writes lands on
+     * every other fleet machine's filesystem too. */
+    sandbox(machineId: string): Promise<SandboxInstance>;
+}
+/** @experimental */
+interface FleetWorkspaceExecutorOptions {
+    fleet: FleetHandle;
+    /**
+     * Override the machine-selection policy. Default = round-robin across
+     * `fleet.ids`, skipping the optional `excludeMachineIds` set (typically the
+     * coordinator machine the MCP server is running on).
+     */
+    selectMachine?: (call: {
+        callIndex: number;
+        ids: ReadonlyArray<string>;
+    }) => string;
+    /**
+     * Machine ids to skip during default round-robin. Set to the caller's own
+     * machineId so workers don't compete with the orchestrator on the same VM.
+     */
+    excludeMachineIds?: ReadonlyArray<string>;
+}
+/**
+ * Build an executor that resolves each delegated iteration to an existing
+ * machine in `fleet`. The fleet's shared-workspace policy means the worker
+ * machine sees the caller's filesystem — diffs land in-place with no
+ * cross-sandbox copy step.
+ *
+ * @experimental
+ */
+declare function createFleetWorkspaceExecutor(options: FleetWorkspaceExecutorOptions): DelegationExecutor;
+
+/**
+ * @experimental
+ *
+ * MCP delegation tool surface — the typed inputs/outputs the product agent
+ * sees over the wire. These types are the contract; the JSON schemas under
+ * `tools/*` mirror them for the MCP `tools/list` advertisement.
+ *
+ * Async semantics: `delegate_code` + `delegate_research` return a `taskId`
+ * immediately. The product agent polls `delegation_status` until the task
+ * transitions to `completed` | `failed` | `cancelled`. `delegate_feedback`
+ * + `delegation_history` are synchronous reads / writes against the local
+ * task queue + feedback store.
+ */
+
+/** @experimental */
+type DelegationProfile = 'coder' | 'researcher';
+/** @experimental */
+type DelegationStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Minimal `CoderTask` overrides exposed over the MCP wire. The full
+ * `CoderTask` carries fields the kernel synthesizes from `goal` +
+ * `repoRoot` — the agent only edits the few that materially gate
+ * validator behavior.
+ *
+ * @experimental
+ */
+interface DelegateCodeConfig {
+    testCmd?: string;
+    typecheckCmd?: string;
+    forbiddenPaths?: string[];
+    maxDiffLines?: number;
+}
+/** @experimental */
+interface DelegateCodeArgs {
+    /** Natural-language description of what the coder must accomplish. */
+    goal: string;
+    /** Absolute path inside the sandbox where the repo lives. */
+    repoRoot: string;
+    /** Optional free-form context the agent surfaces in the prompt prelude. */
+    contextHint?: string;
+    /**
+     * When > 1, dispatches `multiHarnessCoderFanout` across N harnesses
+     * (claude-code, codex, opencode-glm) and picks the highest-scoring
+     * passing patch. Default 1.
+     */
+    variants?: number;
+    /** Validator + prompt overrides the agent knows for this repo. */
+    config?: DelegateCodeConfig;
+    /** Multi-tenant scope (customer-id, workspace-id). */
+    namespace?: string;
+}
+/** @experimental */
+interface DelegateCodeResult {
+    taskId: string;
+    /** Best-effort hint — coder loops can take minutes-to-hours. */
+    estimatedDurationMs?: number;
+}
+/** @experimental */
+type ResearchSource = 'web' | 'corpus' | 'twitter' | 'github' | 'docs';
+/** @experimental */
+interface DelegateResearchConfig {
+    recencyWindow?: {
+        since?: string;
+        until?: string;
+    };
+    maxItems?: number;
+    minConfidence?: number;
+}
+/** @experimental */
+interface DelegateResearchArgs {
+    question: string;
+    namespace: string;
+    scope?: string;
+    sources?: ResearchSource[];
+    variants?: number;
+    config?: DelegateResearchConfig;
+}
+/** @experimental */
+interface DelegateResearchResult {
+    taskId: string;
+    estimatedDurationMs?: number;
+}
+/** @experimental */
+interface FeedbackRefersTo {
+    kind: 'delegation' | 'artifact' | 'outcome';
+    /** For `'delegation'`, this is the taskId. */
+    ref: string;
+}
+/** @experimental */
+interface FeedbackRating {
+    /** [0, 1]. */
+    score: number;
+    label?: 'good' | 'bad' | 'neutral' | 'mixed';
+    notes: string;
+}
+/** @experimental */
+interface DelegateFeedbackArgs {
+    refersTo: FeedbackRefersTo;
+    rating: FeedbackRating;
+    by: 'agent' | 'user' | 'downstream-judge';
+    /** ISO timestamp; defaults to server clock when omitted. */
+    capturedAt?: string;
+    namespace?: string;
+}
+/** @experimental */
+interface DelegateFeedbackResult {
+    recorded: true;
+    id: string;
+}
+/** @experimental */
+interface DelegationStatusArgs {
+    taskId: string;
+}
+/** @experimental */
+interface DelegationProgress {
+    iteration: number;
+    phase: string;
+}
+/** @experimental */
+interface DelegationError {
+    message: string;
+    kind: string;
+}
+/**
+ * Polymorphic `result` field: `CoderOutput` when the underlying profile
+ * is `'coder'`, a structurally-typed research output when `'researcher'`.
+ * The MCP wire carries it as JSON either way.
+ *
+ * @experimental
+ */
+type DelegationResultPayload = {
+    profile: 'coder';
+    output: CoderOutput;
+} | {
+    profile: 'researcher';
+    output: ResearchOutputShape;
+};
+/**
+ * Loose shape of a research output over the wire — the substrate cannot
+ * import the `ResearchOutput` type from agent-knowledge without inducing
+ * a dependency cycle, so the MCP layer treats it structurally.
+ *
+ * @experimental
+ */
+interface ResearchOutputShape {
+    items: unknown[];
+    citations: unknown[];
+    proposedWrites: unknown[];
+    gaps?: string[];
+    notes?: string;
+    [key: string]: unknown;
+}
+/** @experimental */
+interface DelegationStatusResult {
+    taskId: string;
+    profile: DelegationProfile;
+    status: DelegationStatus;
+    progress?: DelegationProgress;
+    result?: DelegationResultPayload;
+    error?: DelegationError;
+    costUsd?: number;
+    startedAt: string;
+    completedAt?: string;
+}
+/** @experimental */
+interface DelegationHistoryArgs {
+    namespace?: string;
+    profile?: DelegationProfile;
+    /** ISO date — only delegations started at-or-after `since` are returned. */
+    since?: string;
+    /** Default 50. Hard cap 500. */
+    limit?: number;
+}
+/** @experimental */
+interface DelegationFeedbackSnapshot {
+    id: string;
+    score: number;
+    label?: FeedbackRating['label'];
+    by: DelegateFeedbackArgs['by'];
+    notes: string;
+    capturedAt: string;
+}
+/** @experimental */
+interface DelegationHistoryEntry {
+    taskId: string;
+    profile: DelegationProfile;
+    namespace?: string;
+    args: DelegateCodeArgs | DelegateResearchArgs;
+    status: DelegationStatus;
+    feedback?: DelegationFeedbackSnapshot[];
+    costUsd?: number;
+    startedAt: string;
+    completedAt?: string;
+}
+/** @experimental */
+interface DelegationHistoryResult {
+    delegations: DelegationHistoryEntry[];
+}
+
+/** @experimental */
+interface DelegateRunCtx {
+    signal: AbortSignal;
+    report(progress: DelegationProgress): void;
+}
+/** @experimental */
+type CoderDelegate = (args: DelegateCodeArgs, ctx: DelegateRunCtx) => Promise<CoderOutput>;
+/** @experimental */
+type ResearcherDelegate = (args: DelegateResearchArgs, ctx: DelegateRunCtx) => Promise<ResearchOutputShape>;
+/** @experimental Structured review verdict over a coder candidate. */
+interface CoderReview {
+    /** Gate: only approved candidates are eligible to win. */
+    approved: boolean;
+    /** Reviewer's recommendation — surfaced in traces. */
+    recommendation: 'ship' | 'approve-with-nits' | 'changes-requested' | 'reject';
+    /** Readiness 0..1, used by the `highest-readiness` winner-selection strategy. */
+    readiness: number;
+    notes?: string;
+}
+/**
+ * @experimental
+ *
+ * Optional adversarial reviewer over a coder candidate that already passed
+ * mechanical validation (tests/typecheck/forbidden/diff/no-op/secrets). Folded
+ * from the ai-trading-blueprint delegation MCP: a candidate is only eligible to
+ * win if the reviewer approves it. The reviewer is the consumer's seam — an LLM
+ * judge, a `pnpm review` command, anything returning a `CoderReview`.
+ */
+type CoderReviewer = (output: CoderOutput, task: CoderTask, ctx: {
+    signal: AbortSignal;
+}) => Promise<CoderReview> | CoderReview;
+/**
+ * @experimental Winner-selection strategy among validated (+ reviewed)
+ * candidates. `highest-readiness` requires a `reviewer`. Default `highest-score`
+ * (the kernel's behavior — preserves backward compatibility).
+ */
+type CoderWinnerSelection = 'highest-score' | 'smallest-diff' | 'highest-readiness' | 'first-approved';
+/** @experimental */
+interface CreateDefaultCoderDelegateOptions {
+    /**
+     * Execution placement. Pass a {@link DelegationExecutor} (sibling or fleet)
+     * to control where worker iterations land. `sandboxClient` is a
+     * convenience shorthand that wraps the client in a sibling executor — pass
+     * one or the other, not both.
+     */
+    executor?: DelegationExecutor;
+    /**
+     * Convenience shorthand for sibling placement. Equivalent to
+     * `executor: createSiblingSandboxExecutor({ client: sandboxClient })`.
+     */
+    sandboxClient?: LoopSandboxClient;
+    /** Default `['claude-code', 'codex', 'opencode/zai-coding-plan/glm-5.1']` when variants > 1. */
+    fanoutHarnesses?: string[];
+    /** Hard cap on the kernel's per-batch concurrency. Default 4. */
+    maxConcurrency?: number;
+    /**
+     * Optional adversarial reviewer. When set, a candidate must pass mechanical
+     * validation AND `reviewer.approved` to be eligible to win — empty/secret/
+     * test-failing patches are already gone; this catches the "compiles + passes
+     * but wrong/unsafe" class the deterministic validator can't see.
+     */
+    reviewer?: CoderReviewer;
+    /** Winner-selection strategy among eligible candidates. Default `highest-score`. */
+    winnerSelection?: CoderWinnerSelection;
+}
+/**
+ * Build a coder delegate that drives `runLoop` against the project's
+ * sandbox client + coder profile. When `args.variants > 1` it switches
+ * to the multi-harness fanout topology.
+ *
+ * @experimental
+ */
+declare function createDefaultCoderDelegate(options: CreateDefaultCoderDelegateOptions): CoderDelegate;
+
+/**
+ * @experimental
+ *
+ * `createKbGate` — the valid-only knowledge-base growth gate, distilled from
+ * physim's KB-research subsystem. A research-in-a-loop delegate (or any KB
+ * writer) runs candidate facts through this before persisting, so the KB grows
+ * with ONLY grounded facts — hallucinated, unsourced, or laundered claims are
+ * vetoed at the gate.
+ *
+ * Fail-closed by construction: every judge must `accept`; the FIRST veto wins
+ * and the fact is rejected. The non-negotiable floor (always on, can't be
+ * disabled) is the **passage-present guard** — a fact's `verbatimPassage` MUST
+ * literally appear in its `sourceText`. That single check kills the dominant
+ * failure mode (a confident claim decoupled from any real source).
+ *
+ * Pure + dependency-free: it operates on fact candidates, not on a store, so it
+ * composes with `@tangle-network/agent-knowledge` or any persistence layer
+ * without importing it. The remediation policy (correct-on-veto vs
+ * escalate-as-unverified) is the caller's — this returns the verdict; it never
+ * drops a fact silently.
+ */
+/** @experimental A fact proposed for the KB, with its grounding. */
+interface FactCandidate {
+    /** The atomic claim text. */
+    claim: string;
+    /** Optional extracted value (number or string) the claim asserts. */
+    value?: string | number;
+    /** Verbatim span lifted from the source that backs the claim. */
+    verbatimPassage: string;
+    /** The raw source text the passage must be grounded in. */
+    sourceText: string;
+    /** Where the fact claims to come from — checked for circular/self citations. */
+    citation?: string;
+}
+/** @experimental */
+interface FactJudgeVerdict {
+    accept: boolean;
+    reason?: string;
+}
+/** @experimental A pluggable fact validator. Throw is NOT allowed — return a
+ *  verdict; a thrown judge is a programmer error, not a veto. */
+interface FactJudge {
+    name: string;
+    judge(candidate: FactCandidate): FactJudgeVerdict | Promise<FactJudgeVerdict>;
+}
+/** @experimental */
+interface KbGateResult {
+    accepted: boolean;
+    /** Name of the judge that vetoed; undefined when accepted. */
+    vetoedBy?: string;
+    reason?: string;
+}
+/** @experimental */
+interface CreateKbGateOptions {
+    /** Extra judges appended after the built-in floor (e.g. an LLM judge). */
+    judges?: FactJudge[];
+    /** Minimum verbatim-passage length. Default 12 — kills empty/stub passages. */
+    minPassageChars?: number;
+    /**
+     * Citation tokens that denote a SELF-generated artifact (e.g. `'spec'`,
+     * `'cad_params'`, `'requirements'`). A citation naming one is circular
+     * (laundering) — the fact cites a derived artifact, not a real source.
+     * Default `[]` (no circular check unless the consumer declares its kinds).
+     */
+    selfArtifactKinds?: string[];
+}
+/**
+ * @experimental
+ *
+ * Build a fail-closed KB gate. The returned function runs the built-in floor
+ * (passage-non-empty → passage-present → value-in-passage → no-circular-citation)
+ * then any consumer judges, returning on the first veto.
+ */
+declare function createKbGate(options?: CreateKbGateOptions): (candidate: FactCandidate) => Promise<KbGateResult>;
+
+/**
+ * @experimental
+ *
+ * OpenAI Chat Completions `tools[]` projection of the 5 agent-runtime MCP
+ * delegation tools.
+ *
+ * Use when configuring `createOpenAICompatibleBackend({ tools: ... })` so the
+ * model can call `delegate_code`, `delegate_research`, `delegate_feedback`,
+ * `delegation_status`, and `delegation_history` through the OpenAI-compat
+ * transport (tcloud, OpenRouter, OpenAI direct, cli-bridge). The runtime
+ * surfaces tool calls as `tool_call` stream events — execution is the
+ * caller's responsibility (typically the parent sandbox runtime's MCP
+ * mount).
+ *
+ * Sandbox-SDK callers do NOT need this helper: the sandbox runtime mounts
+ * MCP servers natively and the in-sandbox harness discovers tools via the
+ * runtime, not via an OpenAI tools array.
+ *
+ * Tool name + description + JSON-schema are pulled from the canonical
+ * `DELEGATE_*` constants exported by `./tools/*` so the projection cannot
+ * drift from the server's own validators.
+ */
+
+/**
+ * @experimental
+ *
+ * Returns the 5 delegation tools projected into OpenAI Chat Completions
+ * `tools[]` shape. The order is stable: `delegate_code`,
+ * `delegate_research`, `delegate_feedback`, `delegation_status`,
+ * `delegation_history`.
+ */
+declare function mcpToolsForRuntimeMcp(): OpenAIChatTool[];
+/**
+ * @experimental
+ *
+ * Subset filter — return only the projected tools whose `function.name`
+ * appears in `names`. Useful for curated mounts (e.g. only the queue-bound
+ * delegation tools, omitting `delegate_feedback`). Unknown names are
+ * silently ignored; pass an empty array to get an empty result.
+ */
+declare function mcpToolsForRuntimeMcpSubset(names: ReadonlyArray<string>): OpenAIChatTool[];
+
+/**
+ * OTEL span exporter — streams LoopTraceEvents to an OTLP/HTTP collector.
+ *
+ * Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env
+ * when no explicit config is given. Keeps the runtime dep-free from
+ * @opentelemetry/sdk-trace-base — minimal OTLP/JSON serializer.
+ *
+ * The exporter accepts both raw OtelSpan objects and LoopTraceEvents
+ * (which get converted to OTLP spans automatically).
+ */
+interface OtelExportConfig {
+    /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */
+    endpoint?: string;
+    /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */
+    headers?: Record<string, string>;
+    /** Batch size before flush. Default 64. */
+    batchSize?: number;
+    /** Flush interval ms. Default 5000. */
+    flushIntervalMs?: number;
+    /** Resource attributes stamped on every export. */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Service name. Default 'agent-runtime'. */
+    serviceName?: string;
+}
+interface OtelExporter {
+    /** Export a span. */
+    exportSpan(span: OtelSpan): void;
+    /** Force flush pending spans. */
+    flush(): Promise<void>;
+    /** Shutdown cleanly. */
+    shutdown(): Promise<void>;
+}
+interface OtelSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind?: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes?: OtelAttribute[];
+    status?: {
+        code: number;
+        message?: string;
+    };
+}
+interface OtelAttribute {
+    key: string;
+    value: {
+        stringValue?: string;
+        intValue?: string;
+        doubleValue?: number;
+        boolValue?: boolean;
+    };
+}
+/**
+ * Create an OTEL exporter. Returns undefined when no endpoint is configured.
+ */
+declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
+/**
+ * Convert a LoopTraceEvent into an OtelSpan for export.
+ */
+declare function loopEventToOtelSpan(event: {
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}, traceId: string, parentSpanId?: string): OtelSpan;
+/**
+ * Build a nested, real-duration OTLP span tree for ONE loop run from its full
+ * ordered `LoopTraceEvent` stream. Unlike `loopEventToOtelSpan` (one flat,
+ * zero-duration span per event), this reconstructs the topology hierarchy a
+ * GenAI trace viewer renders natively:
+ *
+ *   loop (invoke_workflow)
+ *     └─ loop.round[k] (invoke_workflow)   ← tangle.loop.move.{kind,width,rationale}
+ *          ├─ loop.iteration[i] (invoke_agent)  ← gen_ai.agent.name + usage + verdict + placement
+ *          └─ …
+ *
+ * Attributes follow the current GenAI semconv (`gen_ai.*`) where they apply and
+ * a namespaced `tangle.loop.*` / `tangle.cost.usd` extension for topology /
+ * verdict / placement / cost (not yet standardized). Pure: feed it a buffered
+ * per-runId event array (e.g. flushed on `loop.ended`) and export the result.
+ */
+declare function buildLoopOtelSpans(events: ReadonlyArray<{
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}>, traceId: string, rootParentSpanId?: string): OtelSpan[];
+/** Wire version the eval-runs ingest enforces (X-Tangle-Wire-Version + body). */
+declare const INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
+interface EvalRunGeneration {
+    /** 0-based ordinal of this generation within the run (required by ingest). */
+    index: number;
+    /** Identity of the proposed surface change (content-addressed hash). */
+    surfaceHash: string;
+    /** Arbitrary provenance for this generation (rationale, evidence, source). */
+    surface?: unknown;
+    /** Per-scenario results; empty until the generation is measured. */
+    cells?: unknown[];
+    /** Mean composite score (0 when unmeasured — pair with labels.measured). */
+    compositeMean: number;
+    costUsd: number;
+    durationMs: number;
+}
+interface EvalRunEvent {
+    runId: string;
+    runDir: string;
+    /** ISO timestamp. */
+    timestamp: string;
+    status: 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
+    labels?: Record<string, string>;
+    baseline?: EvalRunGeneration;
+    generations?: EvalRunGeneration[];
+    gateDecision?: 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
+    holdoutLift?: number;
+    totalCostUsd: number;
+    totalDurationMs: number;
+    errorMessage?: string;
+}
+interface EvalRunsExportConfig {
+    /** Bearer key — tenant is resolved server-side from it. Reads TANGLE_API_KEY. */
+    apiKey?: string;
+    /** Intelligence base. Reads INTELLIGENCE_BASE env, else prod. */
+    base?: string;
+    /** Idempotency-Key header (e.g. the runId) — safe retries + upsert. */
+    idempotencyKey?: string;
+}
+interface EvalRunsExportResult {
+    ok: boolean;
+    status: number;
+    accepted: number;
+    rejected: Array<{
+        index: number;
+        reason: string;
+    }>;
+}
+/**
+ * Ship self-improvement eval-run events to Tangle Intelligence. Unlike the
+ * best-effort span exporter, this RESOLVES with the ingest verdict (accepted /
+ * rejected per event) so a consumer's loop can assert its provenance landed.
+ * Throws only on a missing key or network failure.
+ */
+declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportConfig): Promise<EvalRunsExportResult>;
+
+export { type OtelSpan as $, type FactCandidate as A, type FactJudge as B, type CoderDelegate as C, type DelegationExecutor as D, type FactJudgeVerdict as E, type FleetHandle as F, type FeedbackRating as G, type FeedbackRefersTo as H, type FleetWorkspaceExecutorOptions as I, type ResearchOutputShape as J, type KbGateResult as K, createDefaultCoderDelegate as L, createFleetWorkspaceExecutor as M, createKbGate as N, type OtelExporter as O, createSiblingSandboxExecutor as P, mcpToolsForRuntimeMcp as Q, type ResearcherDelegate as R, type SiblingSandboxExecutorOptions as S, mcpToolsForRuntimeMcpSubset as T, type EvalRunEvent as U, type EvalRunGeneration as V, type EvalRunsExportConfig as W, type EvalRunsExportResult as X, INTELLIGENCE_WIRE_VERSION as Y, type OtelAttribute as Z, type OtelExportConfig as _, type DelegateFeedbackArgs as a, buildLoopOtelSpans as a0, createOtelExporter as a1, exportEvalRuns as a2, loopEventToOtelSpan as a3, type DelegationFeedbackSnapshot as b, type DelegationProfile as c, type DelegateCodeArgs as d, type DelegateResearchArgs as e, type DelegationStatus as f, type DelegationProgress as g, type DelegationResultPayload as h, type DelegationError as i, type DelegationStatusResult as j, type DelegationHistoryArgs as k, type DelegationHistoryEntry as l, type DelegateCodeResult as m, type DelegateFeedbackResult as n, type ResearchSource as o, type DelegateResearchResult as p, type DelegationHistoryResult as q, type DelegationStatusArgs as r, type CoderReview as s, type CoderReviewer as t, type CoderWinnerSelection as u, type CreateDefaultCoderDelegateOptions as v, type CreateKbGateOptions as w, type DelegateCodeConfig as x, type DelegateResearchConfig as y, type DelegateRunCtx as z };

package/dist/profiles.d.ts

@@ -1,7 +1,6 @@
 import { AgentProfile } from '@tangle-network/sandbox';
-import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-DrXVR2Fu.js';
+import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-CmkQl8qE.js';
 import '@tangle-network/agent-eval';
-import './runtime-run-B8VIiOhI.js';
 import './types-CsCCryln.js';
 
 /**