@tangle-network/agent-runtime 0.18.0 → 0.20.0

package/dist/mcp/index.js

@@ -0,0 +1,74 @@
+import {
+  DELEGATE_CODE_DESCRIPTION,
+  DELEGATE_CODE_INPUT_SCHEMA,
+  DELEGATE_CODE_TOOL_NAME,
+  DELEGATE_FEEDBACK_DESCRIPTION,
+  DELEGATE_FEEDBACK_INPUT_SCHEMA,
+  DELEGATE_FEEDBACK_TOOL_NAME,
+  DELEGATE_RESEARCH_DESCRIPTION,
+  DELEGATE_RESEARCH_INPUT_SCHEMA,
+  DELEGATE_RESEARCH_TOOL_NAME,
+  DELEGATION_HISTORY_DESCRIPTION,
+  DELEGATION_HISTORY_INPUT_SCHEMA,
+  DELEGATION_HISTORY_TOOL_NAME,
+  DELEGATION_STATUS_DESCRIPTION,
+  DELEGATION_STATUS_INPUT_SCHEMA,
+  DELEGATION_STATUS_TOOL_NAME,
+  DelegationTaskQueue,
+  InMemoryFeedbackStore,
+  createDefaultCoderDelegate,
+  createDelegateCodeHandler,
+  createDelegateFeedbackHandler,
+  createDelegateResearchHandler,
+  createDelegationHistoryHandler,
+  createDelegationStatusHandler,
+  createInProcessTransport,
+  createMcpServer,
+  eventToSnapshot,
+  hashIdempotencyInput,
+  validateDelegateCodeArgs,
+  validateDelegateFeedbackArgs,
+  validateDelegateResearchArgs,
+  validateDelegationHistoryArgs,
+  validateDelegationStatusArgs
+} from "../chunk-LPPM7EGS.js";
+import "../chunk-VFUEE6DF.js";
+import "../chunk-Z5LKAYAS.js";
+import "../chunk-XLWPTPRP.js";
+import "../chunk-RZAOYKCO.js";
+import "../chunk-DGUM43GV.js";
+export {
+  DELEGATE_CODE_DESCRIPTION,
+  DELEGATE_CODE_INPUT_SCHEMA,
+  DELEGATE_CODE_TOOL_NAME,
+  DELEGATE_FEEDBACK_DESCRIPTION,
+  DELEGATE_FEEDBACK_INPUT_SCHEMA,
+  DELEGATE_FEEDBACK_TOOL_NAME,
+  DELEGATE_RESEARCH_DESCRIPTION,
+  DELEGATE_RESEARCH_INPUT_SCHEMA,
+  DELEGATE_RESEARCH_TOOL_NAME,
+  DELEGATION_HISTORY_DESCRIPTION,
+  DELEGATION_HISTORY_INPUT_SCHEMA,
+  DELEGATION_HISTORY_TOOL_NAME,
+  DELEGATION_STATUS_DESCRIPTION,
+  DELEGATION_STATUS_INPUT_SCHEMA,
+  DELEGATION_STATUS_TOOL_NAME,
+  DelegationTaskQueue,
+  InMemoryFeedbackStore,
+  createDefaultCoderDelegate,
+  createDelegateCodeHandler,
+  createDelegateFeedbackHandler,
+  createDelegateResearchHandler,
+  createDelegationHistoryHandler,
+  createDelegationStatusHandler,
+  createInProcessTransport,
+  createMcpServer,
+  eventToSnapshot,
+  hashIdempotencyInput,
+  validateDelegateCodeArgs,
+  validateDelegateFeedbackArgs,
+  validateDelegateResearchArgs,
+  validateDelegationHistoryArgs,
+  validateDelegationStatusArgs
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/profiles.d.ts

@@ -0,0 +1,133 @@
+import { AgentProfile } from '@tangle-network/sandbox';
+import { O as OutputAdapter, V as Validator, A as AgentRunSpec, a as Driver } from './types-Bx-tArkc.js';
+import './runtime-run-B2j-hvBj.js';
+import './types-DvJIha6w.js';
+import '@tangle-network/agent-eval';
+
+/**
+ * @experimental
+ *
+ * `coderProfile` — opinionated preset for code-modification tasks.
+ *
+ * The agent is told to:
+ *   - work on a fresh branch inside the sandbox workspace
+ *   - keep the patch minimal (under `maxDiffLines`)
+ *   - avoid `forbiddenPaths`
+ *   - run `testCmd` and `typecheckCmd`
+ *   - emit a final JSON result the output adapter parses
+ *
+ * The profile is stateless and agent-agnostic — `harness` selects the
+ * sandbox-SDK backend (`claude-code`, `codex`, `opencode/*`). For
+ * heterogeneous fanout, use `multiHarnessCoderFanout`.
+ */
+
+/** @experimental */
+interface CoderTask {
+    /** What the agent must accomplish. Free-form prose. */
+    goal: string;
+    /** Absolute path inside the sandbox where the repo lives. */
+    repoRoot: string;
+    /** Default `main`. The branch the agent diffs against. */
+    baseBranch?: string;
+    /** Default `pnpm test --run`. */
+    testCmd?: string;
+    /** Default `pnpm typecheck`. */
+    typecheckCmd?: string;
+    /** Files the agent may inspect for context. Surfaced verbatim in the prompt. */
+    contextFiles?: string[];
+    /**
+     * Paths the agent must not touch. Validator hard-fails on any match.
+     * Use glob-free literal path prefixes for unambiguous enforcement.
+     */
+    forbiddenPaths?: string[];
+    /** Default 400. Hard cap; validator hard-fails when exceeded. */
+    maxDiffLines?: number;
+}
+/** @experimental */
+interface CoderOutput {
+    /** Branch the agent wrote the patch on. */
+    branch: string;
+    /** Unified diff (`git diff <base>..HEAD`). */
+    patch: string;
+    testResult: {
+        passed: boolean;
+        output: string;
+    };
+    typecheckResult: {
+        passed: boolean;
+        output: string;
+    };
+    diffStats: {
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    };
+    /** Optional reviewer commentary surfaced by the agent. */
+    reviewerNotes?: string;
+}
+/** @experimental */
+interface CoderProfileOptions {
+    /** Sandbox-SDK backend.type. Default `'claude-code'`. */
+    harness?: string;
+    /** Default model id passed in `AgentProfile.model.default`. */
+    model?: string;
+    /** Custom system prompt replacement. Default = built-in coder preset. */
+    systemPrompt?: string;
+    /** Stable name for `AgentRunSpec.name`. Default = `coder-${harness}`. */
+    name?: string;
+}
+/**
+ * Build a coder preset.
+ *
+ * `validator` enforces test + typecheck + a 400-line default diff cap. For
+ * per-task `forbiddenPaths` / `maxDiffLines` enforcement, pass `task` here
+ * — the returned validator closes over its constraints. Without a task
+ * the validator falls back to the default cap and skips path enforcement.
+ *
+ * @experimental
+ */
+declare function coderProfile(options?: CoderProfileOptions & {
+    task?: CoderTask;
+}): {
+    profile: AgentProfile;
+    taskToPrompt: (task: CoderTask) => string;
+    output: OutputAdapter<CoderOutput>;
+    validator: Validator<CoderOutput>;
+    agentRunSpec: AgentRunSpec<CoderTask>;
+};
+/** @experimental */
+interface MultiHarnessCoderFanoutOptions {
+    /**
+     * Sandbox-SDK backend.type identifiers, one per parallel agent. Default:
+     * `['claude-code', 'codex', 'opencode/zai-coding-plan/glm-5.1']`.
+     */
+    harnesses?: string[];
+    /** Optional per-harness model override. Indexed parallel to `harnesses`. */
+    models?: (string | undefined)[];
+}
+/** @experimental */
+declare function multiHarnessCoderFanout(options?: MultiHarnessCoderFanoutOptions): {
+    agentRuns: AgentRunSpec<CoderTask>[];
+    output: OutputAdapter<CoderOutput>;
+    validator: Validator<CoderOutput>;
+    driver: Driver<CoderTask, CoderOutput, 'pick-winner' | 'fail'>;
+};
+/**
+ * Build a validator that closes over a specific `CoderTask`'s constraints.
+ *
+ * Checks in order:
+ *   1. Forbidden-path: any `+++` / `---` header in the patch matching a
+ *      path prefix in `task.forbiddenPaths` fails hard.
+ *   2. Diff size: line count above `task.maxDiffLines` (default 400) fails
+ *      hard; below cap, the score shrinks linearly.
+ *   3. Tests: `output.testResult.passed` must be `true`.
+ *   4. Typecheck: `output.typecheckResult.passed` must be `true`.
+ *
+ * Aggregate score: `0.5 * tests + 0.3 * typecheck + 0.2 * (1 - diffLines/maxDiff)`.
+ * `valid` is the conjunction of all four.
+ *
+ * @experimental
+ */
+declare function createCoderValidator(task: CoderTask): Validator<CoderOutput>;
+
+export { type CoderOutput, type CoderProfileOptions, type CoderTask, type MultiHarnessCoderFanoutOptions, coderProfile, createCoderValidator, multiHarnessCoderFanout };

package/dist/profiles.js

@@ -0,0 +1,14 @@
+import {
+  coderProfile,
+  createCoderValidator,
+  multiHarnessCoderFanout
+} from "./chunk-Z5LKAYAS.js";
+import "./chunk-XLWPTPRP.js";
+import "./chunk-RZAOYKCO.js";
+import "./chunk-DGUM43GV.js";
+export {
+  coderProfile,
+  createCoderValidator,
+  multiHarnessCoderFanout
+};
+//# sourceMappingURL=profiles.js.map

package/dist/profiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime-run-B2j-hvBj.d.ts

@@ -0,0 +1,137 @@
+import { A as AgentTaskSpec, R as RuntimeStreamEvent } from './types-DvJIha6w.js';
+
+/**
+ * @stable
+ *
+ * Production-run lifecycle: record what the agent did on behalf of a customer,
+ * what it cost, and how it ended.
+ *
+ * Three concerns live in this module:
+ *
+ *  1. **Lifecycle state machine** — `running` -> `completed | failed | cancelled`,
+ *     enforced by `RuntimeRunStateError`. Completion is idempotent for the same
+ *     status (a second `complete()` call is a no-op so retries / cleanup paths
+ *     don't double-fire side effects). A different terminal status is a state
+ *     error.
+ *
+ *  2. **Cost ledger** — every `llm_call` event the handle observes contributes
+ *     `tokensIn`, `tokensOut`, `costUsd`, and bumps `llmCalls`. Wall time is
+ *     measured from `startRuntimeRun()` to `complete()`. Surface via
+ *     `handle.cost()` for cost-per-task dashboards.
+ *
+ *  3. **Persistence adapter** — `RuntimeRunPersistenceAdapter` is the seam
+ *     consumers plug in to write a `RuntimeRunRow` to their D1 / postgres /
+ *     KV store. The adapter receives a sanitized row shape; no telemetry
+ *     payload bytes flow through it unless the consumer opts in via
+ *     `RuntimeRunOptions.telemetryEvents`.
+ */
+
+/** @stable */
+type RuntimeRunStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+/** @stable */
+interface RuntimeRunCost {
+    /** Cumulative input tokens across every observed `llm_call` event. */
+    tokensIn: number;
+    /** Cumulative output tokens across every observed `llm_call` event. */
+    tokensOut: number;
+    /** Sum of `costUsd` from every observed `llm_call` event. */
+    costUsd: number;
+    /** Wall time from `startRuntimeRun()` to `complete()` (or `now()` if not yet completed). */
+    wallMs: number;
+    /** Count of `llm_call` events observed during the run. */
+    llmCalls: number;
+}
+/** @stable */
+interface RuntimeRunCompleteInput {
+    status: Exclude<RuntimeRunStatus, 'running'>;
+    resultSummary?: string;
+    /** Optional explicit cost override; if omitted, the accumulated ledger is used. */
+    cost?: Partial<RuntimeRunCost>;
+    /** Stable error message when `status === 'failed'`. */
+    error?: string;
+    /** Additional adapter-specific fields merged into the persisted row. */
+    metadata?: Record<string, unknown>;
+}
+/** @stable */
+interface RuntimeRunRow {
+    /** Stable runtime-side identifier. Adapters may translate to their own primary key. */
+    id: string;
+    workspaceId: string;
+    sessionId?: string;
+    agentId?: string;
+    domain?: string;
+    taskId: string;
+    scenarioId?: string;
+    status: RuntimeRunStatus;
+    resultSummary?: string;
+    error?: string;
+    cost: RuntimeRunCost;
+    startedAt: string;
+    completedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+/** @stable */
+interface RuntimeRunPersistenceAdapter {
+    /**
+     * Called once when `handle.persist()` runs. Implementations write `row` to
+     * their durable store (D1, postgres, KV) and return whatever the consumer
+     * wants the caller to see (often the storage-side row id). Errors thrown
+     * here propagate out of `persist()` so the caller can decide whether to
+     * retry or log-and-continue.
+     */
+    upsert(row: RuntimeRunRow): Promise<void> | void;
+}
+/** @stable */
+interface RuntimeRunOptions {
+    workspaceId: string;
+    sessionId?: string;
+    agentId?: string;
+    taskSpec: AgentTaskSpec;
+    scenarioId?: string;
+    /** Optional persistence adapter; if omitted, `persist()` is a no-op. */
+    adapter?: RuntimeRunPersistenceAdapter;
+    /** Override the row id; default = `${taskSpec.id}:${random suffix}`. */
+    id?: string;
+    /** Override the clock; default = `Date.now()`. Useful for deterministic tests. */
+    now?: () => number;
+}
+/** @stable */
+interface RuntimeRunHandle {
+    /** Stable id assigned at start. */
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly sessionId: string | undefined;
+    readonly taskSpec: AgentTaskSpec;
+    readonly status: RuntimeRunStatus;
+    /**
+     * Observe a single `RuntimeStreamEvent`. The handle ignores non-cost events
+     * (text deltas, tool calls) silently so consumers can pipe the whole stream
+     * through `handle.observe`. `llm_call` events update the ledger.
+     */
+    observe(event: RuntimeStreamEvent): void;
+    /** Snapshot of the current cost ledger. Safe to call at any time. */
+    cost(): RuntimeRunCost;
+    /**
+     * Transition to a terminal state. Idempotent for the same status; throws
+     * `RuntimeRunStateError` for a different terminal status (state machines
+     * don't time-travel).
+     */
+    complete(input: RuntimeRunCompleteInput): void;
+    /** Build the current row without writing it. Useful for tests + dry runs. */
+    toRow(metadata?: Record<string, unknown>): RuntimeRunRow;
+    /**
+     * Persist the current row via the configured adapter. Must be called after
+     * `complete()`. Idempotent for the same terminal state (the adapter sees
+     * the same row on retry).
+     */
+    persist(metadata?: Record<string, unknown>): Promise<void>;
+}
+/**
+ * @stable
+ *
+ * Construct a runtime-run handle. The returned handle is mutable across its
+ * lifetime; consumers should not share it across requests.
+ */
+declare function startRuntimeRun(options: RuntimeRunOptions): RuntimeRunHandle;
+
+export { type RuntimeRunHandle as R, type RuntimeRunPersistenceAdapter as a, type RuntimeRunRow as b, startRuntimeRun as s };

package/dist/types-Bx-tArkc.d.ts

@@ -0,0 +1,225 @@
+import { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
+import { R as RuntimeRunHandle } from './runtime-run-B2j-hvBj.js';
+
+/**
+ * @experimental
+ *
+ * Driven-loop substrate — type surface.
+ *
+ * The loop kernel orchestrates around the sandbox SDK; it does not invent
+ * its own notion of "what an agent is". Each iteration is a sandbox-SDK
+ * `streamPrompt` call against an `AgentProfile`. The kernel owns iteration
+ * accounting, concurrency, abort propagation, cost aggregation, and trace
+ * emission; the driver owns topology (plan + decide); the validator owns
+ * output scoring; the output adapter owns event-stream → typed-output decode.
+ */
+
+/** @experimental */
+interface DefaultVerdict {
+    /** Whether the output meets the validator's pass criteria. */
+    valid: boolean;
+    /** Aggregate score in [0, 1]. Drivers use this for winner selection. */
+    score: number;
+    /** Per-dimension scores. Free-form; weighted into `score` by the validator. */
+    scores?: Record<string, number>;
+    /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */
+    notes?: string;
+}
+/** @experimental */
+interface ValidationCtx {
+    /** Iteration index this output came from (0-based). */
+    iteration: number;
+    /** Cooperative cancellation channel. */
+    signal: AbortSignal;
+}
+/** @experimental */
+interface Validator<Output, Verdict = DefaultVerdict> {
+    validate(output: Output, ctx: ValidationCtx): Promise<Verdict>;
+}
+/**
+ * Sandbox-SDK-shaped agent specification.
+ *
+ * The kernel uses `profile` to instantiate a sandbox per iteration, formats
+ * `task` into a prompt via `taskToPrompt`, and merges `sandboxOverrides` into
+ * the `CreateSandboxOptions` it passes to `client.create`. Heterogeneous
+ * fanout supplies multiple `AgentRunSpec`s and the kernel round-robins
+ * through them when the driver plans N tasks.
+ *
+ * @experimental
+ */
+interface AgentRunSpec<Task> {
+    /** Sandbox SDK profile — what kind of agent runs the task. */
+    profile: AgentProfile;
+    /** Task → prompt formatter. Pure and deterministic. */
+    taskToPrompt: (task: Task) => string;
+    /**
+     * Per-spec stable name. Surfaced in trace events and the default winner
+     * selector tiebreak. Falls back to `profile.name ?? 'agent'`.
+     */
+    name?: string;
+    /**
+     * Optional sandbox-SDK `CreateSandboxOptions` overrides merged on top of
+     * the kernel's defaults. `backend.profile` is set to `profile` by the
+     * kernel and cannot be overridden here — use `profile` itself for that.
+     */
+    sandboxOverrides?: Partial<Omit<CreateSandboxOptions, 'backend'>> & {
+        backend?: Omit<NonNullable<CreateSandboxOptions['backend']>, 'profile'>;
+    };
+}
+/**
+ * Stream of `SandboxEvent`s → typed `Output`.
+ *
+ * Adapters are pure functions over the already-collected event array; they
+ * do not receive the live AsyncIterable so they can be replayed against
+ * persisted streams during tests / replays.
+ *
+ * @experimental
+ */
+interface OutputAdapter<Output> {
+    parse(events: SandboxEvent[]): Output;
+}
+/** @experimental */
+interface Iteration<Task, Output> {
+    /** 0-based iteration index assigned by the kernel. */
+    index: number;
+    task: Task;
+    /** Stable name of the `AgentRunSpec` that produced this iteration. */
+    agentRunName: string;
+    output?: Output;
+    verdict?: DefaultVerdict;
+    error?: Error;
+    /** Raw sandbox event stream collected for this iteration. */
+    events: SandboxEvent[];
+    startedAt: number;
+    endedAt: number;
+    costUsd: number;
+}
+/** @experimental */
+interface Driver<Task, Output, Decision> {
+    /**
+     * Stable identifier surfaced in trace events. Default `'driver'`.
+     */
+    readonly name?: string;
+    /**
+     * Tasks to issue this iteration. `[task]` → refine; N copies → fanout;
+     * `[]` → no more work this round (kernel proceeds to `decide`).
+     */
+    plan(task: Task, history: ReadonlyArray<Iteration<Task, Output>>): Promise<Task[]>;
+    /**
+     * Inspect history and return the next state. The kernel terminates the
+     * loop when `decide` returns a value listed in `isTerminalDecision`
+     * (`'stop' | 'pick-winner' | 'fail' | 'done'`), when `maxIterations`
+     * is hit, or when the abort signal fires.
+     */
+    decide(history: ReadonlyArray<Iteration<Task, Output>>): Decision | Promise<Decision>;
+}
+/** @experimental */
+interface LoopWinner<Task, Output> {
+    task: Task;
+    output: Output;
+    verdict?: DefaultVerdict;
+    iterationIndex: number;
+    agentRunName: string;
+}
+/** @experimental */
+interface LoopResult<Task, Output, Decision> {
+    decision: Decision;
+    iterations: Iteration<Task, Output>[];
+    winner?: LoopWinner<Task, Output>;
+    durationMs: number;
+    /** Sum of every iteration's `costUsd`. */
+    costUsd: number;
+}
+/**
+ * Minimal sandbox client surface the kernel calls. Satisfied structurally by
+ * `new Sandbox({ apiKey, baseUrl })` — declared as a structural type so
+ * tests can pass a stub without instantiating the SDK.
+ *
+ * @experimental
+ */
+interface LoopSandboxClient {
+    create(options?: CreateSandboxOptions): Promise<SandboxInstance>;
+}
+/** @experimental */
+interface LoopTraceEmitter {
+    emit(event: LoopTraceEvent): void | Promise<void>;
+}
+/** @experimental */
+type LoopTraceEvent = {
+    kind: 'loop.started';
+    runId: string;
+    timestamp: number;
+    payload: LoopStartedPayload;
+} | {
+    kind: 'loop.iteration.started';
+    runId: string;
+    timestamp: number;
+    payload: LoopIterationStartedPayload;
+} | {
+    kind: 'loop.iteration.ended';
+    runId: string;
+    timestamp: number;
+    payload: LoopIterationEndedPayload;
+} | {
+    kind: 'loop.decision';
+    runId: string;
+    timestamp: number;
+    payload: LoopDecisionPayload;
+} | {
+    kind: 'loop.ended';
+    runId: string;
+    timestamp: number;
+    payload: LoopEndedPayload;
+};
+/** @experimental */
+interface LoopStartedPayload {
+    driver: string;
+    agentRunNames: string[];
+    maxIterations: number;
+    maxConcurrency: number;
+}
+/** @experimental */
+interface LoopIterationStartedPayload {
+    iterationIndex: number;
+    agentRunName: string;
+    taskHash: string;
+}
+/** @experimental */
+interface LoopIterationEndedPayload {
+    iterationIndex: number;
+    agentRunName: string;
+    outputHash?: string;
+    verdict?: DefaultVerdict;
+    error?: string;
+    costUsd: number;
+    durationMs: number;
+}
+/** @experimental */
+interface LoopDecisionPayload {
+    decision: string;
+    historyLength: number;
+}
+/** @experimental */
+interface LoopEndedPayload {
+    winnerIterationIndex?: number;
+    totalCostUsd: number;
+    durationMs: number;
+    iterations: number;
+}
+/** @experimental */
+interface ExecCtx {
+    /** Sandbox SDK client — the kernel calls `.create()` per iteration. */
+    sandboxClient: LoopSandboxClient;
+    /** Optional trace emitter. When set, the kernel emits `loop.*` events. */
+    traceEmitter?: LoopTraceEmitter;
+    /**
+     * Optional production-run handle. When set, every synthesized `llm_call`
+     * the kernel infers from a sandbox event stream is forwarded via
+     * `runHandle.observe` so per-run cost aggregates pick up loop spend.
+     */
+    runHandle?: RuntimeRunHandle;
+    /** Cooperative cancellation signal. */
+    signal?: AbortSignal;
+}
+
+export type { AgentRunSpec as A, DefaultVerdict as D, ExecCtx as E, Iteration as I, LoopWinner as L, OutputAdapter as O, Validator as V, Driver as a, LoopResult as b, LoopDecisionPayload as c, LoopEndedPayload as d, LoopIterationEndedPayload as e, LoopIterationStartedPayload as f, LoopSandboxClient as g, LoopStartedPayload as h, LoopTraceEmitter as i, LoopTraceEvent as j, ValidationCtx as k };

package/dist/{types-ByIhNRFk.d.ts → types-DvJIha6w.d.ts}

@@ -376,4 +376,4 @@ interface KnowledgeReadinessDecision {
     nonBlockingGapIds: string[];
 }
 
-export type { AgentBackendInput as A, KnowledgeReadinessDecision as K, RuntimeStreamEvent as R, AgentExecutionBackend as a, AgentBackendContext as b, RunAgentTaskOptions as c, AgentTaskRunResult as d, RunAgentTaskStreamOptions as e, AgentTaskSpec as f, AgentRuntimeEvent as g, AgentTaskStatus as h, RuntimeSessionStore as i, RuntimeSession as j, AgentAdapter as k, AgentKnowledgeProvider as l, AgentRuntimeEventSink as m, AgentTaskContext as n };
+export type { AgentTaskSpec as A, KnowledgeReadinessDecision as K, RuntimeStreamEvent as R, AgentBackendInput as a, AgentExecutionBackend as b, AgentBackendContext as c, RunAgentTaskOptions as d, AgentTaskRunResult as e, RunAgentTaskStreamOptions as f, AgentRuntimeEvent as g, AgentTaskStatus as h, RuntimeSessionStore as i, RuntimeSession as j, AgentAdapter as k, AgentKnowledgeProvider as l, AgentRuntimeEventSink as m, AgentTaskContext as n };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Reusable runtime lifecycle for domain-specific agents.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -33,8 +33,26 @@
       "types": "./dist/agent.d.ts",
       "import": "./dist/agent.js",
       "default": "./dist/agent.js"
+    },
+    "./loops": {
+      "types": "./dist/loops.d.ts",
+      "import": "./dist/loops.js",
+      "default": "./dist/loops.js"
+    },
+    "./profiles": {
+      "types": "./dist/profiles.d.ts",
+      "import": "./dist/profiles.js",
+      "default": "./dist/profiles.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "import": "./dist/mcp/index.js",
+      "default": "./dist/mcp/index.js"
     }
   },
+  "bin": {
+    "agent-runtime-mcp": "./dist/mcp/bin.js"
+  },
   "files": [
     "dist",
     "README.md"
@@ -78,6 +96,12 @@
   "license": "MIT",
   "packageManager": "pnpm@10.28.0",
   "peerDependencies": {
+    "@tangle-network/agent-knowledge": ">=1.3.0 <2.0.0",
     "@tangle-network/sandbox": ">=0.1.2 <0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@tangle-network/agent-knowledge": {
+      "optional": true
+    }
   }
 }