@agen-ai/agent-orchestration 0.0.0-stage → 0.4.0

package/dist/execution/state.d.ts

@@ -0,0 +1,107 @@
+import type { AgentProviderSession, AgentProviderSessionCleanupError, AgentProviderTurnExecution } from "@agen-ai/agent-runtime";
+import type { AgentRequest, AgentSessionId, AgentTurnId } from "@agen-ai/agent-protocol";
+import type { DelegationTarget } from "../catalog/types.js";
+import type { CreateDelegationCoordinatorOptions } from "../coordinator/types.js";
+import type { DelegationChildResources, DelegationContinuation, DelegationExecutionLease, DelegationHostRequestHandle } from "../host/types.js";
+import type { DelegationCommitReceipt, DelegationMutationFence, DelegationStoreCommand } from "../store/types.js";
+import type { DelegationOwnerToken, DelegationParentScope, DelegationPolicyCeiling, DelegationResultReference, DelegationRunOutcome, DelegationRunRecord, DelegationTaskRecord, DelegationTaskView } from "../tasks/types.js";
+export interface ParentBinding {
+    readonly scope: DelegationParentScope;
+    readonly ancestor?: Readonly<{
+        taskId: string;
+        runId: string;
+    }>;
+    readonly ceiling?: DelegationPolicyCeiling;
+    readonly depth?: number;
+}
+export interface LiveRequest {
+    readonly handle: DelegationHostRequestHandle;
+    readonly live: LiveRun;
+    readonly request: AgentRequest;
+}
+export interface LiveRun {
+    readonly taskId: string;
+    readonly runId: string;
+    readonly scope: DelegationParentScope;
+    readonly target: DelegationTarget;
+    readonly ceiling: DelegationPolicyCeiling;
+    readonly lifetime: AbortController;
+    readonly controlAbort: AbortController;
+    readonly sessionId: AgentSessionId;
+    readonly turnId: AgentTurnId;
+    readonly controls: Set<Promise<unknown>>;
+    readonly pendingOperations: Map<string, Readonly<{
+        digest: string;
+        promise: Promise<unknown>;
+    }>>;
+    execution?: DelegationExecutionLease;
+    resources?: DelegationChildResources;
+    session?: AgentProviderSession;
+    turn?: AgentProviderTurnExecution;
+    rejectedOpening?: AgentProviderSessionCleanupError;
+    stream?: Promise<void>;
+    request?: LiveRequest;
+    requestResolution?: Promise<unknown>;
+    observedStart: boolean;
+    recordedStart: boolean;
+    controlTail: Promise<void>;
+    uncertain?: Extract<DelegationRunOutcome, {
+        kind: "recovery_required";
+    }>["reason"];
+    terminal?: DelegationRunOutcome;
+    summary: string;
+    truncated: boolean;
+    references: DelegationResultReference[];
+    runtimeCleanupAttempts: number;
+    resourceReleaseAttempts: number;
+    executionReleaseAttempts: number;
+    runtimeClosed: boolean;
+    resourcesReleased: boolean;
+    executionReleased: boolean;
+    cleanup?: Promise<boolean>;
+    cancellation?: Promise<unknown>;
+    finishing?: Promise<void>;
+    ready?: Promise<void>;
+    requestHistory?: DelegationRunRecord["pendingRequest"];
+    schedule?: () => void;
+    deadline?: ReturnType<typeof setTimeout>;
+    removeRevocation?: () => void;
+}
+export declare class CoordinatorState {
+    readonly options: CreateDelegationCoordinatorOptions;
+    readonly owner: DelegationOwnerToken;
+    readonly live: Map<string, LiveRun>;
+    readonly continuations: Map<string, DelegationContinuation>;
+    readonly requests: WeakMap<DelegationHostRequestHandle, LiveRequest>;
+    readonly waiters: Set<() => void>;
+    readonly producers: Set<Promise<unknown>>;
+    readonly deliveryCalls: Map<string, Readonly<{
+        controller: AbortController;
+        taskId: string;
+        promise: Promise<unknown>;
+    }>>;
+    closing: boolean;
+    draining: boolean;
+    failed: boolean;
+    released: boolean;
+    pump?: Promise<void>;
+    queueTimer?: ReturnType<typeof setTimeout>;
+    schedulePending: boolean;
+    onFailure?: () => void;
+    wakeDelivery?: () => void;
+    stopDelivery?: (abort: boolean) => void;
+    private tail;
+    constructor(options: CreateDelegationCoordinatorOptions, owner: DelegationOwnerToken);
+    gate<Value>(action: () => Promise<Value>): Promise<Value>;
+    changed(): void;
+    fail(): void;
+    track<Value>(promise: Promise<Value>, live?: LiveRun): Promise<Value>;
+    task(taskId: string): Promise<DelegationTaskView>;
+    run(taskId: string, runId: string): Promise<DelegationRunRecord>;
+    commit(command: DelegationStoreCommand): Promise<DelegationCommitReceipt>;
+    mutate(taskId: string, runId: string, operationId: string, inputDigest: string, command: (fence: DelegationMutationFence, task: DelegationTaskRecord, run: DelegationRunRecord) => DelegationStoreCommand | undefined): Promise<DelegationCommitReceipt | undefined>;
+}
+export declare function sameScopeIdentity(left: DelegationParentScope, right: DelegationParentScope): boolean;
+export declare function now(): string;
+export declare function truncateUtf8(text: string, maximum: number): string;
+//# sourceMappingURL=state.d.ts.map

package/dist/execution/state.js

@@ -0,0 +1,120 @@
+import { DelegationOperationError, failDelegation } from "../shared/operational-errors.js";
+class CoordinatorState {
+  constructor(options, owner) {
+    this.options = options;
+    this.owner = owner;
+  }
+  options;
+  owner;
+  live = /* @__PURE__ */ new Map();
+  continuations = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new WeakMap();
+  waiters = /* @__PURE__ */ new Set();
+  producers = /* @__PURE__ */ new Set();
+  deliveryCalls = /* @__PURE__ */ new Map();
+  closing = false;
+  draining = false;
+  failed = false;
+  released = false;
+  pump;
+  queueTimer;
+  schedulePending = false;
+  onFailure;
+  wakeDelivery;
+  stopDelivery;
+  tail = Promise.resolve();
+  gate(action) {
+    const next = this.tail.then(action, action);
+    this.tail = next.catch(() => void 0);
+    return next;
+  }
+  changed() {
+    for (const waiter of this.waiters) waiter();
+    this.waiters.clear();
+  }
+  fail() {
+    const first = !this.failed;
+    this.failed = true;
+    this.closing = true;
+    this.draining = false;
+    if (this.queueTimer) {
+      clearTimeout(this.queueTimer);
+      this.queueTimer = void 0;
+    }
+    this.stopDelivery?.(true);
+    if (first) this.onFailure?.();
+    this.changed();
+  }
+  track(promise, live) {
+    this.producers.add(promise);
+    live?.controls.add(promise);
+    void promise.finally(() => {
+      this.producers.delete(promise);
+      live?.controls.delete(promise);
+      this.changed();
+    }).catch(() => void 0);
+    return promise;
+  }
+  async task(taskId) {
+    const result = await this.options.store.read({ kind: "task", taskId, limit: this.options.limits.maxPageRecords });
+    if (result.kind !== "task" || !result.view) return failDelegation("request_unavailable", "The managed task is unavailable.");
+    return result.view;
+  }
+  async run(taskId, runId) {
+    const result = await this.options.store.read({ kind: "run", taskId, runId });
+    if (result.kind !== "run" || !result.run) return failDelegation("request_unavailable", "The managed run is unavailable.");
+    return result.run;
+  }
+  async commit(command) {
+    if (this.released) failDelegation("owner_lost", "The coordinator no longer owns this store.");
+    try {
+      const receipt = await this.options.store.commit(command);
+      this.changed();
+      if (command.kind === "settle" || command.kind === "cancel") this.wakeDelivery?.();
+      return receipt;
+    } catch (error) {
+      if (error instanceof DelegationOperationError && error.code !== "store_failed" && error.code !== "owner_lost") throw error;
+      this.fail();
+      if (error instanceof DelegationOperationError) throw error;
+      return failDelegation("store_failed", "The managed store could not commit this operation.");
+    }
+  }
+  mutate(taskId, runId, operationId, inputDigest, command) {
+    return this.gate(async () => {
+      const [{ task }, run] = await Promise.all([this.task(taskId), this.run(taskId, runId)]);
+      const mutation = command({
+        owner: this.owner,
+        operationId,
+        inputDigest,
+        taskId,
+        expectedTaskRevision: task.revision,
+        runId,
+        expectedRunRevision: run.revision
+      }, task, run);
+      return mutation === void 0 ? void 0 : this.commit(mutation);
+    });
+  }
+}
+function sameScopeIdentity(left, right) {
+  return left.parentId === right.parentId && left.scopeId === right.scopeId;
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function truncateUtf8(text, maximum) {
+  const encoder = new TextEncoder();
+  let bytes = 0;
+  let result = "";
+  for (const character of text) {
+    bytes += encoder.encode(character).byteLength;
+    if (bytes > maximum) break;
+    result += character;
+  }
+  return result;
+}
+export {
+  CoordinatorState,
+  now,
+  sameScopeIdentity,
+  truncateUtf8
+};

package/dist/execution/stream.d.ts

@@ -0,0 +1,9 @@
+import type { AgentProviderOutput } from "@agen-ai/agent-runtime";
+import type { DelegationHistoricalRequest } from "../tasks/types.js";
+import { type CoordinatorState, type LiveRun } from "./state.js";
+export declare function markRequest(state: CoordinatorState, live: LiveRun, stateChange: "opened" | "resolution_intended" | "resolved" | "unavailable", request: DelegationHistoricalRequest, identity?: {
+    operationId: string;
+    inputDigest: string;
+}): Promise<void>;
+export declare function consumeTurn(state: CoordinatorState, live: LiveRun, outputs: AsyncIterable<AgentProviderOutput>): Promise<void>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/execution/stream.js

@@ -0,0 +1,108 @@
+import { delegationDataBytes, delegationInputDigest, delegationSubordinateId } from "../shared/identity.js";
+import { fitDelegationText } from "../shared/text.js";
+import { projectDelegationFailure } from "../tasks/failure.js";
+import { parseDelegationResultReference } from "../tasks/parse.js";
+import { finishRun } from "./finish.js";
+import { operationIdentity, operationReceipt } from "./journal.js";
+import { now } from "./state.js";
+function accumulate(live, text) {
+  const candidate = live.summary + text;
+  const bounded = fitDelegationText(candidate, (value) => delegationDataBytes({ text: value, truncated: false, references: live.references }) <= 8192);
+  if (bounded !== candidate) live.truncated = true;
+  live.summary = bounded;
+}
+async function observe(state, live, projection) {
+  const id = delegationSubordinateId(live.runId, "observations");
+  await state.mutate(live.taskId, live.runId, id, delegationInputDigest({ runId: live.runId, kind: "observe" }), (fence, _task, run) => {
+    const base = { storeId: state.options.store.storeId, taskId: live.taskId, runId: live.runId, index: run.observationIndex + 1, at: now(), ...projection };
+    const text = base.text === void 0 ? void 0 : fitDelegationText(base.text, (value) => delegationDataBytes({ ...base, text: value }) <= state.options.limits.maxObservationBytes);
+    return { ...fence, kind: "observe", observation: { ...base, ...text === void 0 ? {} : { text } } };
+  });
+}
+async function markRequest(state, live, stateChange, request, identity = operationIdentity(live, `request:${request.requestId}:${stateChange}`)) {
+  await state.mutate(
+    live.taskId,
+    live.runId,
+    identity.operationId,
+    identity.inputDigest,
+    (fence) => ({ ...fence, kind: "request_state", state: stateChange, request, at: now() })
+  );
+}
+async function routeRequest(state, live, request) {
+  const historical = {
+    requestId: request.requestId,
+    requestKind: request.requestKind,
+    openedAt: now(),
+    ...request.expiresAt ? { expiresAt: request.expiresAt } : {},
+    state: "waiting"
+  };
+  await markRequest(state, live, "opened", historical);
+  live.requestHistory = historical;
+  const handle = Object.freeze({});
+  const pending = { handle, live, request };
+  live.request = pending;
+  state.requests.set(handle, pending);
+  await observe(state, live, { kind: "request", request: historical });
+  const callback = Promise.resolve().then(async () => {
+    const [{ task }, run] = await Promise.all([state.task(live.taskId), state.run(live.taskId, live.runId)]);
+    if (live.lifetime.signal.aborted || live.request !== pending) return;
+    await state.options.host.onRequest({ handle, task, run, request, signal: live.lifetime.signal });
+  });
+  state.track(callback, live);
+  void callback.catch(() => {
+    live.uncertain = "request_executor_lost";
+    void finishRun(state, live, { kind: "recovery_required", reason: "request_executor_lost" }).catch(() => void 0);
+  });
+}
+async function reduceOutput(state, live, output) {
+  if (live.observedStart && !live.recordedStart) {
+    await operationReceipt(state, live, "delegated", operationIdentity(live, "turn"));
+    live.recordedStart = true;
+  }
+  if (output.kind === "artifact" && state.options.host.publishArtifact && live.references.length < 8) {
+    const [{ task }, run] = await Promise.all([state.task(live.taskId), state.run(live.taskId, live.runId)]);
+    const reference = parseDelegationResultReference(await state.options.host.publishArtifact({ task, run, candidate: output.candidate, signal: live.lifetime.signal }));
+    if (delegationDataBytes(reference) <= 256 && delegationDataBytes({ text: live.summary, truncated: live.truncated, references: [...live.references, reference] }) <= 8192) live.references.push(reference);
+    else live.truncated = true;
+  }
+  if (output.kind !== "event") return {};
+  const event = output.event;
+  if (event.type === "content.delta" && event.payload.streamKind === "assistant_text") {
+    accumulate(live, event.payload.delta);
+    await observe(state, live, { kind: "text", text: event.payload.delta });
+  } else if (event.type === "turn.started") await observe(state, live, { kind: "state", phase: "running" });
+  else if (event.type === "request.opened") return { request: event.payload.request };
+  else if (event.type === "turn.completed") {
+    return { terminal: event.payload.outcome === "completed" ? { kind: "succeeded", result: { text: live.summary, truncated: live.truncated, references: [...live.references] } } : event.payload.outcome === "canceled" ? { kind: "canceled", confirmation: "provider_terminal" } : { kind: "failed", error: projectDelegationFailure(event.payload.error) } };
+  }
+  return {};
+}
+async function consumeTurn(state, live, outputs) {
+  let terminal;
+  try {
+    for await (const output of outputs) {
+      const projected = await reduceOutput(state, live, output);
+      if (projected.request || projected.terminal) await live.requestResolution?.catch(() => void 0);
+      if (projected.request && !live.uncertain && !live.lifetime.signal.aborted) await routeRequest(state, live, projected.request);
+      terminal = projected.terminal ?? terminal;
+    }
+    live.stream = void 0;
+    if (!terminal) terminal = { kind: "recovery_required", reason: live.cancellation ? "cancellation_uncertain" : live.requestHistory ? "request_executor_lost" : "dispatch_uncertain" };
+  } catch {
+    live.stream = void 0;
+    terminal = live.observedStart ? { kind: "recovery_required", reason: live.uncertain ?? (live.cancellation ? "cancellation_uncertain" : "dispatch_uncertain") } : { kind: "failed", error: { category: "unknown", code: "turn_rejected", message: "The managed child turn was rejected before provider execution.", recovery: { kind: "unknown" } } };
+    if (!live.observedStart) {
+      try {
+        await operationReceipt(state, live, "rejected", operationIdentity(live, "turn"));
+      } catch {
+        live.uncertain = "storage_failed";
+      }
+    }
+  }
+  live.terminal = terminal;
+  await finishRun(state, live, terminal);
+}
+export {
+  consumeTurn,
+  markRequest
+};

package/dist/host/types.d.ts

@@ -0,0 +1,95 @@
+import type { AgentArtifactCandidate, AgentProviderRegistry, AgentProviderSession, AgentSessionHostBinding, MaybePromise } from "@agen-ai/agent-runtime";
+import type { AgentConfigurationCatalog, AgentRequest, AgentSessionBinding, AgentSessionConfiguration } from "@agen-ai/agent-protocol";
+import type { DelegationTarget, DelegationTargetCatalog, DelegationTargetReference } from "../catalog/types.js";
+import type { DelegationPolicySnapshot } from "../policy/types.js";
+import type { DelegationParentScope, DelegationResultReference, DelegationRunRecord, DelegationTaskRecord } from "../tasks/types.js";
+export interface DelegationExecutionLease {
+    readonly signal: AbortSignal;
+    readonly assertCurrent: () => void;
+    readonly release: () => MaybePromise<void>;
+}
+export interface DelegationHostPolicy {
+    readonly scope: DelegationParentScope;
+    readonly catalog: DelegationTargetCatalog;
+    readonly policy: DelegationPolicySnapshot;
+}
+export interface DelegationContinuation {
+    readonly runId: string;
+    readonly binding: AgentSessionBinding;
+    readonly target: DelegationTarget;
+}
+export interface DelegationChildResources {
+    readonly workingDirectory: Readonly<{
+        policy: "shared" | "isolated";
+        authorizedRef: string;
+        path: string;
+    }>;
+    readonly hostBinding?: AgentSessionHostBinding;
+    readonly continuation?: Readonly<{
+        kind: "resume";
+        allowTargetChange: boolean;
+    }>;
+    /** Owns unclaimed binding cleanup; shares once-success release state with hostBinding.release. */
+    readonly release: () => MaybePromise<void>;
+}
+export interface DelegationAppliedConfiguration {
+    readonly target: DelegationTargetReference;
+    readonly configuration: AgentSessionConfiguration;
+}
+declare const requestHandleBrand: unique symbol;
+export interface DelegationHostRequestHandle {
+    readonly [requestHandleBrand]: true;
+}
+export interface DelegationHostRequest {
+    readonly handle: DelegationHostRequestHandle;
+    readonly task: DelegationTaskRecord;
+    readonly run: DelegationRunRecord;
+    readonly request: AgentRequest;
+}
+export interface DelegationHost {
+    readonly registry: AgentProviderRegistry;
+    readonly currentPolicy: (scope: DelegationParentScope) => DelegationHostPolicy;
+    readonly assertResultAccess: (input: Readonly<{
+        scope: DelegationParentScope;
+        task?: DelegationTaskRecord;
+    }>) => void;
+    readonly assertControl: (input: Readonly<{
+        scope: DelegationParentScope;
+        task: DelegationTaskRecord;
+    }>) => void;
+    readonly assertRequestAccess: (input: DelegationHostRequest) => void;
+    readonly acquireExecution: (input: Readonly<{
+        scope: DelegationParentScope;
+        task: DelegationTaskRecord;
+        run: DelegationRunRecord;
+        target: DelegationTarget;
+        signal: AbortSignal;
+    }>) => MaybePromise<DelegationExecutionLease>;
+    readonly acquireChildResources: (input: Readonly<{
+        scope: DelegationParentScope;
+        task: DelegationTaskRecord;
+        run: DelegationRunRecord;
+        target: DelegationTarget;
+        continuation?: DelegationContinuation;
+        signal: AbortSignal;
+    }>) => MaybePromise<DelegationChildResources>;
+    readonly verifyAppliedConfiguration: (input: Readonly<{
+        task: DelegationTaskRecord;
+        run: DelegationRunRecord;
+        target: DelegationTarget;
+        session: AgentProviderSession;
+        observedConfiguration?: AgentConfigurationCatalog;
+        signal: AbortSignal;
+    }>) => MaybePromise<DelegationAppliedConfiguration>;
+    readonly onRequest: (input: DelegationHostRequest & Readonly<{
+        signal: AbortSignal;
+    }>) => MaybePromise<void>;
+    readonly publishArtifact?: (input: Readonly<{
+        task: DelegationTaskRecord;
+        run: DelegationRunRecord;
+        candidate: AgentArtifactCandidate;
+        signal: AbortSignal;
+    }>) => MaybePromise<DelegationResultReference>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export type { DelegationExecutionMode, DelegationReasoning, DelegationSemanticFact, DelegationTarget, DelegationTargetCatalog, DelegationTargetOption, DelegationTargetReference, } from "./catalog/types.js";
+export { parseDelegationTargetCatalog } from "./catalog/parse.js";
+export type { DelegationDeveloperPolicy, DelegationExclusion, DelegationPolicyOutcome, DelegationPolicySnapshot, DelegationTargetDecision, DelegationTargetIdentity, DelegationUserPolicy, DelegationUserSelection, ResolvedDelegationPolicy, } from "./policy/types.js";
+export { parseDelegationPolicySnapshot } from "./policy/parse.js";
+export { resolveDelegationPolicy } from "./policy/resolve.js";
+export { DelegationValidationError, type DelegationValidationIssue } from "./shared/errors.js";
+export { DelegationOperationError, type DelegationErrorCode, } from "./shared/operational-errors.js";
+export { DEFAULT_DELEGATION_LIMITS, parseDelegationLimits, type DelegationLimits, } from "./shared/limits.js";
+export type { CreateDelegationCoordinatorOptions, DelegationAdmissionReceipt, DelegationBindingSnapshot, DelegationCancelReceipt, DelegationClient, DelegationCoordinator, DelegationRecoveryPage, DelegationRequestReceipt, DelegationResolveHostRequestInput, DelegationSendReceipt, DelegationSendTaskInput, DelegationShutdownReceipt, DelegationSpawnTaskInput, DelegationTargetPage, DelegationWaitReceipt, } from "./coordinator/types.js";
+export { createDelegationCoordinator } from "./coordinator/create.js";
+export type { DelegationInboxAcceptance, DelegationInboxInspection, DelegationParentDeliveryPort, } from "./delivery/types.js";
+export { parseDelegationInboxAcceptance, parseDelegationInboxInspection, } from "./delivery/parse.js";
+export type { DelegationAppliedConfiguration, DelegationChildResources, DelegationContinuation, DelegationExecutionLease, DelegationHost, DelegationHostPolicy, DelegationHostRequest, DelegationHostRequestHandle, } from "./host/types.js";
+export type { DelegationCommitReceipt, DelegationCriticalSlot, DelegationDeliveryResult, DelegationMutationFence, DelegationOperationDisposition, DelegationOperationKind, DelegationOperationRecord, DelegationRunAdmission, DelegationStore, DelegationStoreCapacity, DelegationStoreCommand, DelegationStoreReadInput, DelegationStoreReadPage, DelegationStoreScanInput, DelegationStoreScanPage, } from "./store/types.js";
+export { createInMemoryDelegationStore } from "./store/memory.js";
+export type { DelegationCompletionEnvelope, DelegationCompletionPolicy, DelegationDeliveryCommitRecord, DelegationHistoricalRequest, DelegationNotificationRecord, DelegationObservationGap, DelegationObservedTaskObservation, DelegationOwnerToken, DelegationPage, DelegationParentScope, DelegationPersistence, DelegationPolicyCeiling, DelegationPublicFailure, DelegationResultReference, DelegationResultSummary, DelegationRunOutcome, DelegationRunPhase, DelegationRunRecord, DelegationRunSummary, DelegationTaskObservation, DelegationTaskRecord, DelegationTaskState, DelegationTaskView, } from "./tasks/types.js";
+export { createDelegationPolicyCeiling, parseDelegationCompletionEnvelope, parseDelegationHistoricalRequest, parseDelegationNotificationRecord, parseDelegationOwnerToken, parseDelegationParentScope, parseDelegationPolicyCeiling, parseDelegationResultReference, parseDelegationRunOutcome, parseDelegationRunRecord, parseDelegationTaskObservation, parseDelegationTaskRecord, } from "./tasks/parse.js";
+export { createDelegationHostBinding } from "./tools/create.js";
+export type { CreateDelegationHostBindingOptions, DelegationToolTarget, DelegationToolTargetPage, DelegationToolRunSummary, DelegationToolTaskStatus, } from "./tools/types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,58 @@
+import { parseDelegationTargetCatalog } from "./catalog/parse.js";
+import { parseDelegationPolicySnapshot } from "./policy/parse.js";
+import { resolveDelegationPolicy } from "./policy/resolve.js";
+import { DelegationValidationError } from "./shared/errors.js";
+import {
+  DelegationOperationError
+} from "./shared/operational-errors.js";
+import {
+  DEFAULT_DELEGATION_LIMITS,
+  parseDelegationLimits
+} from "./shared/limits.js";
+import { createDelegationCoordinator } from "./coordinator/create.js";
+import {
+  parseDelegationInboxAcceptance,
+  parseDelegationInboxInspection
+} from "./delivery/parse.js";
+import { createInMemoryDelegationStore } from "./store/memory.js";
+import {
+  createDelegationPolicyCeiling,
+  parseDelegationCompletionEnvelope,
+  parseDelegationHistoricalRequest,
+  parseDelegationNotificationRecord,
+  parseDelegationOwnerToken,
+  parseDelegationParentScope,
+  parseDelegationPolicyCeiling,
+  parseDelegationResultReference,
+  parseDelegationRunOutcome,
+  parseDelegationRunRecord,
+  parseDelegationTaskObservation,
+  parseDelegationTaskRecord
+} from "./tasks/parse.js";
+import { createDelegationHostBinding } from "./tools/create.js";
+export {
+  DEFAULT_DELEGATION_LIMITS,
+  DelegationOperationError,
+  DelegationValidationError,
+  createDelegationCoordinator,
+  createDelegationHostBinding,
+  createDelegationPolicyCeiling,
+  createInMemoryDelegationStore,
+  parseDelegationCompletionEnvelope,
+  parseDelegationHistoricalRequest,
+  parseDelegationInboxAcceptance,
+  parseDelegationInboxInspection,
+  parseDelegationLimits,
+  parseDelegationNotificationRecord,
+  parseDelegationOwnerToken,
+  parseDelegationParentScope,
+  parseDelegationPolicyCeiling,
+  parseDelegationPolicySnapshot,
+  parseDelegationResultReference,
+  parseDelegationRunOutcome,
+  parseDelegationRunRecord,
+  parseDelegationTargetCatalog,
+  parseDelegationTaskObservation,
+  parseDelegationTaskRecord,
+  resolveDelegationPolicy
+};

package/dist/mcp/bridge.d.ts

@@ -0,0 +1,4 @@
+import type { DelegationMcpBridge, StartDelegationMcpBridgeOptions } from "./types.js";
+/** Starts one scoped listener. Pure runtime validation does not claim or release the supplied binding. */
+export declare function startDelegationMcpBridge(options: StartDelegationMcpBridgeOptions): Promise<DelegationMcpBridge>;
+//# sourceMappingURL=bridge.d.ts.map