@graphrefly/ts 0.0.0 → 0.0.2

package/dist/orchestration/index.js

@@ -1,6 +1,44 @@
 import {
-  timeout
-} from "../chunk-JR4IKCR2.js";
+  admitAgentRequestProposal,
+  agentRequestLedgerViews,
+  agentRequestProposalFromDecision,
+  breakerBundle,
+  constantBackoff,
+  effectRun,
+  effectRunCompletionProjector,
+  fakeExecutorBlocked,
+  fakeExecutorCanceled,
+  fakeExecutorFailure,
+  fakeExecutorResult,
+  fakeExecutorTimeout,
+  issueAgentRequest,
+  processBundle,
+  processEffectRunner,
+  rateLimitBundle,
+  requestSatisfactionProjector,
+  retryStatusBundle,
+  scheduledReadinessProjector,
+  structuredAgentDecisionInterpreter,
+  timeoutBundle,
+  toolProviderRunAdmissionProjector,
+  toolProviderRunRetryProjector
+} from "../chunk-STXRMPW4.js";
+import {
+  buildToolProviderAdapterInputs,
+  executorOutcomeViewProjector,
+  localBuiltinToolProviderCatalog,
+  resolveToolProviderExecutionPolicies,
+  toolProviderAdapterInputProjector,
+  toolProviderPolicyResolutionProjector,
+  validateToolProviderExecutionPolicy
+} from "../chunk-MTELVIYR.js";
+import {
+  buildToolProviderExecutorOutcome,
+  requestToolProviderAdapterRun,
+  toolProviderAdapterRunProjector
+} from "../chunk-7GOTIIQ7.js";
+import "../chunk-TQPCAIQI.js";
+import "../chunk-TPND5MJS.js";
 import {
   backoffDelayMs,
   nextRetryDelayMs,
@@ -8,997 +46,51 @@ import {
   retryPolicy,
   shouldRetry
 } from "../chunk-OOEN33FB.js";
-import "../chunk-G4M3NHRJ.js";
-import "../chunk-PKVBHGBM.js";
-import "../chunk-I3IHOHCJ.js";
-import "../chunk-4VLAQHZI.js";
-import {
-  depBatch
-} from "../chunk-SWTLEQL6.js";
-import "../chunk-DK554R7P.js";
-
-// src/orchestration/index.ts
-var processCommandSources = /* @__PURE__ */ new WeakMap();
-function retryStatusBundle(graph, events, opts = {}) {
-  const policy = opts.policy ?? retryPolicy();
-  const name = opts.name ?? "retry";
-  const status = graph.node(
-    [events],
-    (ctx) => {
-      let next = ctx.state.get() ?? { state: "idle", attempt: 0, maxAttempts: policy.maxAttempts };
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const event = raw;
-        if (event.kind === "attempt") {
-          next = { state: "running", attempt: event.attempt, maxAttempts: policy.maxAttempts };
-        } else if (event.kind === "retry") {
-          next = {
-            state: "waiting",
-            attempt: event.attempt,
-            maxAttempts: policy.maxAttempts,
-            delayMs: event.delayMs
-          };
-        } else if (event.kind === "success") {
-          next = {
-            state: "succeeded",
-            attempt: event.attempt ?? next.attempt,
-            maxAttempts: policy.maxAttempts
-          };
-        } else if (event.kind === "failure") {
-          const attempt = event.attempt ?? next.attempt;
-          next = {
-            state: shouldRetry(policy, attempt) ? "failed" : "exhausted",
-            attempt,
-            maxAttempts: policy.maxAttempts,
-            delayMs: shouldRetry(policy, attempt) ? nextRetryDelayMs(policy, attempt + 1) : void 0
-          };
-        } else {
-          next = {
-            state: "exhausted",
-            attempt: event.attempt,
-            maxAttempts: policy.maxAttempts
-          };
-        }
-      }
-      ctx.state.set(next);
-      ctx.down([["DATA", next]]);
-    },
-    { name: `${name}/status`, factory: "retryStatus" }
-  );
-  const errors = graph.node(
-    [events],
-    (ctx) => {
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const event = raw;
-        if ("error" in event) ctx.down([["DATA", event.error]]);
-      }
-    },
-    { name: `${name}/errors`, factory: "retryErrors" }
-  );
-  return { status, errors };
-}
-function breakerBundle(graph, events, opts) {
-  if (!Number.isInteger(opts.failureThreshold) || opts.failureThreshold <= 0) {
-    throw new RangeError("breakerBundle: failureThreshold must be a positive integer");
-  }
-  const name = opts.name ?? "breaker";
-  const now = opts.now ?? Date.now;
-  const status = graph.node(
-    [events],
-    (ctx) => {
-      let next = ctx.state.get() ?? { state: "closed", failures: 0 };
-      if (next.state === "open" && opts.resetAfterMs !== void 0 && next.openedAtMs !== void 0 && now() - next.openedAtMs >= opts.resetAfterMs) {
-        next = { ...next, state: "half-open" };
-      }
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const event = raw;
-        if (event.kind === "success") {
-          next = { state: "closed", failures: 0 };
-        } else if (event.kind === "failure" || event.kind === "exhausted") {
-          const failures = next.failures + 1;
-          next = failures >= opts.failureThreshold ? { state: "open", failures, openedAtMs: now() } : { ...next, failures };
-        }
-      }
-      ctx.state.set(next);
-      ctx.down([["DATA", next]]);
-    },
-    { name: `${name}/status`, factory: "breakerStatus" }
-  );
-  const allowed = graph.node(
-    [status],
-    (ctx) => {
-      const statusBatch = depBatch(ctx, 0) ?? [];
-      for (const value of statusBatch) {
-        ctx.down([["DATA", value.state !== "open"]]);
-      }
-    },
-    { name: `${name}/allowed`, factory: "breakerAllowed" }
-  );
-  return { status, allowed };
-}
-function rateLimitBundle(graph, source, opts) {
-  if (!Number.isInteger(opts.max) || opts.max <= 0) {
-    throw new RangeError("rateLimitBundle: max must be a positive integer");
-  }
-  if (!Number.isFinite(opts.windowMs) || opts.windowMs <= 0) {
-    throw new RangeError("rateLimitBundle: windowMs must be positive");
-  }
-  const now = opts.now ?? Date.now;
-  const name = opts.name ?? "rateLimit";
-  const events = graph.node(
-    [source],
-    (ctx) => {
-      const current = now();
-      let state = ctx.state.get() ?? { count: 0, resetAtMs: current + opts.windowMs, allowed: 0, dropped: 0 };
-      if (current >= state.resetAtMs) {
-        state = { ...state, count: 0, resetAtMs: current + opts.windowMs };
-      }
-      for (const value of depBatch(ctx, 0) ?? []) {
-        const allowed2 = state.count < opts.max;
-        state = allowed2 ? { ...state, count: state.count + 1, allowed: state.allowed + 1 } : { ...state, dropped: state.dropped + 1 };
-        const status2 = {
-          allowed: state.allowed,
-          dropped: state.dropped,
-          remaining: Math.max(0, opts.max - state.count),
-          resetAtMs: state.resetAtMs
-        };
-        ctx.down([
-          [
-            "DATA",
-            allowed2 ? { kind: "allowed", value, status: status2 } : { kind: "dropped", value, status: status2 }
-          ]
-        ]);
-      }
-      ctx.state.set(state);
-    },
-    { name: `${name}/events`, factory: "rateLimitEvents" }
-  );
-  const allowed = graph.node(
-    [events],
-    (ctx) => {
-      for (const event of depBatch(ctx, 0) ?? []) {
-        const typed = event;
-        if (typed.kind === "allowed") ctx.down([["DATA", typed.value]]);
-      }
-    },
-    { name: `${name}/allowed`, factory: "rateLimitAllowed" }
-  );
-  const dropped = graph.node(
-    [events],
-    (ctx) => {
-      for (const event of depBatch(ctx, 0) ?? []) {
-        const typed = event;
-        if (typed.kind === "dropped") ctx.down([["DATA", typed.value]]);
-      }
-    },
-    { name: `${name}/dropped`, factory: "rateLimitDropped" }
-  );
-  const status = graph.node(
-    [events],
-    (ctx) => {
-      for (const event of depBatch(ctx, 0) ?? []) {
-        ctx.down([["DATA", event.status]]);
-      }
-    },
-    { name: `${name}/status`, factory: "rateLimitStatus" }
-  );
-  return { allowed, dropped, status };
-}
-function timeoutBundle(graph, source, ms, opts = {}) {
-  const name = opts.name ?? "timeout";
-  const node = timeout(source, ms);
-  const status = graph.node(
-    [node],
-    (ctx) => {
-      const terminal = ctx.terminal[0];
-      if (terminal === true) ctx.down([["DATA", "completed"]]);
-      else if (terminal !== false && terminal !== void 0) ctx.down([["DATA", "errored"]]);
-      else if ((depBatch(ctx, 0) ?? []).length > 0) ctx.down([["DATA", "running"]]);
-    },
-    { name: `${name}/status`, factory: "timeoutStatus" }
-  );
-  const errors = graph.node(
-    [node],
-    (ctx) => {
-      const terminal = ctx.terminal[0];
-      if (terminal !== true && terminal !== false && terminal !== void 0) {
-        ctx.down([["DATA", terminal]]);
-      }
-    },
-    { name: `${name}/errors`, factory: "timeoutErrors" }
-  );
-  return { node, status, errors };
-}
-function processBundle(graph, opts) {
-  if (typeof opts.reduce !== "function") {
-    throw new TypeError("processBundle: reduce must be a function");
-  }
-  if (opts.initialState === void 0) {
-    throw new TypeError("processBundle: initialState must not be undefined");
-  }
-  const name = opts.name ?? "process";
-  const now = opts.now ?? Date.now;
-  const topology = graph.topologyGroup({ name: `${name}.process` });
-  const command = topology.node([], null, {
-    name: `${name}/command`,
-    factory: "processCommand",
-    completeWhenDepsComplete: false,
-    errorWhenDepsError: false
-  });
-  const runtime = topology.node(
-    [command],
-    (ctx) => {
-      let state2 = ctx.state.get() ?? {
-        eventSeq: 0,
-        effectSeq: 0,
-        commandCount: 0,
-        errorCount: 0,
-        auditSeq: 0,
-        seenEventIds: [],
-        seenEffectIds: [],
-        state: opts.initialState
-      };
-      ctx.state.persist(true);
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        state2 = reduceProcessCommandFact(
-          raw,
-          state2,
-          opts.reduce,
-          now,
-          (fact) => ctx.down([["DATA", fact]])
-        );
-        ctx.state.set(state2);
-      }
-    },
-    {
-      name: `${name}/runtime`,
-      factory: "processRuntime",
-      meta: { process: "facts-plus-reducer", d: "D136" },
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-  const events = processProjection(
-    topology,
-    runtime,
-    `${name}/events`,
-    "processEvents",
-    (fact) => fact.kind === "event" ? fact.event : void 0
-  );
-  const state = processProjection(
-    topology,
-    runtime,
-    `${name}/state`,
-    "processState",
-    (fact) => fact.kind === "state" ? fact.state : void 0
-  );
-  const audit = processProjection(
-    topology,
-    runtime,
-    `${name}/audit`,
-    "processAudit",
-    (fact) => fact.kind === "audit" ? fact.audit : void 0
-  );
-  const effectRequests = processProjection(
-    topology,
-    runtime,
-    `${name}/effectRequests`,
-    "processEffectRequests",
-    (fact) => fact.kind === "effect-request" ? fact.effect : void 0
-  );
-  const status = processProjection(
-    topology,
-    runtime,
-    `${name}/status`,
-    "processStatus",
-    (fact) => fact.kind === "status" ? fact.status : void 0
-  );
-  const errors = processProjection(
-    topology,
-    runtime,
-    `${name}/errors`,
-    "processErrors",
-    (fact) => fact.kind === "error" ? fact.error : void 0
-  );
-  const cursor = processProjection(
-    topology,
-    runtime,
-    `${name}/cursor`,
-    "processCursor",
-    (fact) => fact.kind === "cursor" ? fact.cursor : void 0
-  );
-  const retainProcessNodes = () => [
-    graph.retain(runtime, { reason: `${name}.process.runtime` }),
-    graph.retain(events, { reason: `${name}.process.events` }),
-    graph.retain(state, { reason: `${name}.process.state` }),
-    graph.retain(audit, { reason: `${name}.process.audit` }),
-    graph.retain(effectRequests, { reason: `${name}.process.effectRequests` }),
-    graph.retain(status, { reason: `${name}.process.status` }),
-    graph.retain(errors, { reason: `${name}.process.errors` }),
-    graph.retain(cursor, { reason: `${name}.process.cursor` })
-  ];
-  let releaseRetains = retainProcessNodes();
-  let released = false;
-  const bundle = {
-    command,
-    events,
-    state,
-    audit,
-    effectRequests,
-    status,
-    errors,
-    cursor,
-    dispatch(next) {
-      command.down([["DATA", next]]);
-      return next;
-    },
-    release() {
-      if (released) return;
-      const activeRetains = releaseRetains;
-      releaseRetains = [];
-      for (const releaseRetain of activeRetains) releaseRetain();
-      try {
-        topology.release({ reason: `${name}.process.release` });
-        released = true;
-        processCommandSources.delete(
-          bundle
-        );
-      } catch (error) {
-        releaseRetains = retainProcessNodes();
-        throw error;
-      }
-    }
-  };
-  processCommandSources.set(
-    bundle,
-    { sources: [] }
-  );
-  return bundle;
-}
-function processEffectRunner(graph, process, opts) {
-  if (opts.outcomes.length === 0) {
-    throw new RangeError("processEffectRunner: outcomes must contain at least one node");
-  }
-  const name = opts.name ?? "processEffectRunner";
-  const topology = graph.topologyGroup({ name: `${name}.effectRunner` });
-  const requests = topology.node(
-    [process.effectRequests],
-    (ctx) => {
-      for (const request of depBatch(ctx, 0) ?? []) {
-        ctx.down([["DATA", request]]);
-      }
-    },
-    {
-      name: `${name}/requests`,
-      factory: "processEffectRunnerRequests",
-      partial: true,
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-  const runtime = topology.node(
-    [...opts.outcomes],
-    (ctx) => {
-      for (let i = 0; i < opts.outcomes.length; i += 1) {
-        for (const raw of depBatch(ctx, i) ?? []) {
-          const parsed = parseProcessEffectOutcome(raw);
-          if (typeof parsed === "string") {
-            const error = {
-              code: "malformed-outcome",
-              message: parsed,
-              outcome: raw
-            };
-            ctx.down([["DATA", { kind: "error", error }]]);
-            continue;
-          }
-          const outcome = parsed;
-          const command = processEffectOutcomeCommand(outcome);
-          ctx.down([["DATA", { kind: "outcome", outcome }]]);
-          ctx.down([["DATA", { kind: "command", command }]]);
-        }
-      }
-    },
-    {
-      name: `${name}/runtime`,
-      factory: "processEffectRunner",
-      meta: { process: "effect-runner", d: "D156" },
-      partial: true,
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-  const outcomes = processEffectRunnerProjection(
-    topology,
-    runtime,
-    `${name}/outcomes`,
-    "processEffectRunnerOutcomes",
-    (fact) => fact.kind === "outcome" ? fact.outcome : void 0
-  );
-  const commands = processEffectRunnerProjection(
-    topology,
-    runtime,
-    `${name}/commands`,
-    "processEffectRunnerCommands",
-    (fact) => fact.kind === "command" ? fact.command : void 0
-  );
-  const errors = processEffectRunnerProjection(
-    topology,
-    runtime,
-    `${name}/errors`,
-    "processEffectRunnerErrors",
-    (fact) => fact.kind === "error" ? fact.error : void 0
-  );
-  const status = topology.node(
-    [requests, runtime],
-    (ctx) => {
-      let state = ctx.state.get() ?? { requested: 0, commanded: 0, rejected: 0 };
-      for (const request of depBatch(ctx, 0) ?? []) {
-        state = { ...state, requested: state.requested + 1 };
-        const typedRequest = request;
-        ctx.down([
-          [
-            "DATA",
-            {
-              state: "requested",
-              effectId: typedRequest.id,
-              effectType: typedRequest.type,
-              requested: state.requested,
-              commanded: state.commanded,
-              rejected: state.rejected
-            }
-          ]
-        ]);
-      }
-      for (const fact of depBatch(ctx, 1) ?? []) {
-        const typedFact = fact;
-        if (typedFact.kind === "command") {
-          state = { ...state, commanded: state.commanded + 1 };
-          ctx.down([
-            [
-              "DATA",
-              {
-                state: "commanded",
-                effectId: typedFact.command.payload.effectId,
-                effectType: typedFact.command.payload.effectType,
-                commandId: typedFact.command.id,
-                commandType: typedFact.command.type,
-                requested: state.requested,
-                commanded: state.commanded,
-                rejected: state.rejected
-              }
-            ]
-          ]);
-        }
-        if (typedFact.kind === "error") {
-          state = { ...state, rejected: state.rejected + 1 };
-          ctx.down([
-            [
-              "DATA",
-              {
-                state: "rejected",
-                effectId: typedFact.error.effectId,
-                effectType: typedFact.error.effectType,
-                requested: state.requested,
-                commanded: state.commanded,
-                rejected: state.rejected
-              }
-            ]
-          ]);
-        }
-      }
-      ctx.state.set(state);
-    },
-    {
-      name: `${name}/status`,
-      factory: "processEffectRunnerStatus",
-      partial: true,
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-  const retainRunnerNodes = () => [
-    graph.retain(requests, { reason: `${name}.effectRunner.requests` }),
-    graph.retain(outcomes, { reason: `${name}.effectRunner.outcomes` }),
-    graph.retain(commands, { reason: `${name}.effectRunner.commands` }),
-    graph.retain(status, { reason: `${name}.effectRunner.status` }),
-    graph.retain(errors, { reason: `${name}.effectRunner.errors` })
-  ];
-  let releaseRetains = retainRunnerNodes();
-  try {
-    attachProcessCommandSource(process, commands);
-  } catch (error) {
-    for (const releaseRetain of releaseRetains) releaseRetain();
-    releaseRetains = [];
-    topology.release({ reason: `${name}.effectRunner.failedAttach` });
-    throw error;
-  }
-  let released = false;
-  return {
-    requests,
-    outcomes,
-    commands,
-    status,
-    errors,
-    release() {
-      if (released) return;
-      const activeRetains = releaseRetains;
-      releaseRetains = [];
-      for (const releaseRetain of activeRetains) releaseRetain();
-      detachProcessCommandSource(process, commands);
-      try {
-        topology.release({ reason: `${name}.effectRunner.release` });
-        released = true;
-      } catch (error) {
-        attachProcessCommandSource(process, commands);
-        releaseRetains = retainRunnerNodes();
-        throw error;
-      }
-    }
-  };
-}
-function constantBackoff(delayMs) {
-  return { kind: "constant", delayMs };
-}
-function processEffectRunnerProjection(topology, runtime, name, factory, pick) {
-  return topology.node(
-    [runtime],
-    (ctx) => {
-      for (const fact of depBatch(ctx, 0) ?? []) {
-        const value = pick(fact);
-        if (value !== void 0) ctx.down([["DATA", value]]);
-      }
-    },
-    {
-      name,
-      factory,
-      partial: true,
-      completeWhenDepsComplete: false,
-      errorWhenDepsError: false
-    }
-  );
-}
-function parseProcessEffectOutcome(raw) {
-  if (!isObjectRecord(raw)) return "processEffectRunner: outcome must be an object";
-  if (typeof raw.kind !== "string") {
-    return "processEffectRunner: outcome kind must be a string";
-  }
-  if (raw.kind !== "result" && raw.kind !== "failure" && raw.kind !== "cancel" && raw.kind !== "timeout") {
-    return "processEffectRunner: outcome kind must be result, failure, cancel, or timeout";
-  }
-  if (typeof raw.effectId !== "string" || raw.effectId.length === 0) {
-    return "processEffectRunner: outcome effectId must be a non-empty string";
-  }
-  if (typeof raw.effectType !== "string" || raw.effectType.length === 0) {
-    return "processEffectRunner: outcome effectType must be a non-empty string";
-  }
-  if ("commandId" in raw && raw.commandId !== void 0) {
-    if (typeof raw.commandId !== "string" || raw.commandId.length === 0) {
-      return "processEffectRunner: outcome commandId must be a non-empty string";
-    }
-  }
-  for (const key of ["processId", "correlationId", "causationId"]) {
-    if (key in raw && raw[key] !== void 0 && typeof raw[key] !== "string") {
-      return `processEffectRunner: outcome ${key} must be a string`;
-    }
-  }
-  if ("metadata" in raw && raw.metadata !== void 0 && !isObjectRecord(raw.metadata)) {
-    return "processEffectRunner: outcome metadata must be a plain object";
-  }
-  if (raw.kind === "result" && !("value" in raw)) {
-    return "processEffectRunner: result outcome must carry value";
-  }
-  if ((raw.kind === "failure" || raw.kind === "timeout") && !("error" in raw)) {
-    return `processEffectRunner: ${raw.kind} outcome must carry error`;
-  }
-  if (raw.kind === "cancel" && "reason" in raw && raw.reason !== void 0 && typeof raw.reason !== "string") {
-    return "processEffectRunner: cancel outcome reason must be a string";
-  }
-  return raw;
-}
-function processEffectOutcomeCommand(outcome) {
-  const commandType = processEffectCommandType(outcome.kind);
-  return {
-    id: outcome.commandId ?? `${outcome.effectId}:${commandType}`,
-    type: commandType,
-    payload: processEffectCommandPayload(outcome),
-    processId: outcome.processId,
-    correlationId: outcome.correlationId,
-    causationId: outcome.causationId,
-    metadata: outcome.metadata
-  };
-}
-function processEffectCommandType(kind) {
-  switch (kind) {
-    case "result":
-      return "effect.result";
-    case "failure":
-      return "effect.failure";
-    case "cancel":
-      return "effect.cancel";
-    case "timeout":
-      return "effect.timeout";
-  }
-}
-function processEffectCommandPayload(outcome) {
-  const base = {
-    effectId: outcome.effectId,
-    effectType: outcome.effectType,
-    processId: outcome.processId,
-    correlationId: outcome.correlationId,
-    causationId: outcome.causationId,
-    metadata: outcome.metadata
-  };
-  switch (outcome.kind) {
-    case "result":
-      return { ...base, kind: "result", value: outcome.value };
-    case "failure":
-      return { ...base, kind: "failure", error: outcome.error };
-    case "cancel":
-      return { ...base, kind: "cancel", reason: outcome.reason };
-    case "timeout":
-      return { ...base, kind: "timeout", error: outcome.error };
-  }
-}
-function attachProcessCommandSource(process, source) {
-  const attached = processCommandSources.get(process);
-  if (attached === void 0) {
-    throw new Error("processEffectRunner: process command source registry missing");
-  }
-  const sources = attached.sources;
-  const previousSources = [...sources];
-  if (!sources.includes(source)) sources.push(source);
-  try {
-    process.command.replaceDeps([...sources], processCommandSourceFn(sources.length));
-  } catch (error) {
-    sources.splice(0, sources.length, ...previousSources);
-    process.command.replaceDeps(
-      [...previousSources],
-      processCommandSourceFn(previousSources.length)
-    );
-    throw error;
-  }
-}
-function detachProcessCommandSource(process, source) {
-  const attached = processCommandSources.get(process);
-  if (attached === void 0) {
-    throw new Error("processEffectRunner: process command source registry missing");
-  }
-  const sources = attached.sources;
-  if (!sources.includes(source)) return;
-  const previousSources = [...sources];
-  const nextSources = sources.filter((candidate) => candidate !== source);
-  sources.splice(0, sources.length, ...nextSources);
-  try {
-    process.command.replaceDeps([...nextSources], processCommandSourceFn(nextSources.length));
-  } catch (error) {
-    sources.splice(0, sources.length, ...previousSources);
-    process.command.replaceDeps(
-      [...previousSources],
-      processCommandSourceFn(previousSources.length)
-    );
-    throw error;
-  }
-}
-function processCommandSourceFn(sourceCount) {
-  return (ctx) => {
-    for (let i = 0; i < sourceCount; i += 1) {
-      for (const command of depBatch(ctx, i) ?? []) {
-        ctx.down([["DATA", command]]);
-      }
-    }
-  };
-}
-function processRuntimeDraft(state) {
-  return {
-    eventSeq: state.eventSeq,
-    effectSeq: state.effectSeq,
-    commandCount: state.commandCount,
-    errorCount: state.errorCount,
-    auditSeq: state.auditSeq,
-    seenEventIds: [...state.seenEventIds],
-    seenEffectIds: [...state.seenEffectIds],
-    state: state.state
-  };
-}
-function reduceProcessCommandFact(raw, state, reduce, now, emit) {
-  const draft = processRuntimeDraft(state);
-  draft.commandCount += 1;
-  const parsed = parseProcessCommand(raw);
-  if (typeof parsed === "string") {
-    emitProcessFailure(draft, emit, raw, void 0, "malformed-command", parsed);
-    return draft;
-  }
-  const command = parsed;
-  let reduction;
-  const reducerState = cloneProcessState(state.state);
-  if (!reducerState.ok) {
-    emitProcessFailure(draft, emit, command, command, "malformed-state", reducerState.message);
-    return draft;
-  }
-  try {
-    reduction = reduce(command, reducerState.value);
-  } catch (error) {
-    rethrowGraphRuntimeInvariant(error);
-    emitProcessFailure(draft, emit, command, command, "reducer-threw", errorMessage(error));
-    return draft;
-  }
-  if (!isObjectRecord(reduction) || !("state" in reduction)) {
-    emitProcessFailure(
-      draft,
-      emit,
-      command,
-      command,
-      "malformed-state",
-      "processBundle: reducer must return { state, events?, effects? }"
-    );
-    return draft;
-  }
-  if (reduction.state === void 0) {
-    emitProcessFailure(
-      draft,
-      emit,
-      command,
-      command,
-      "malformed-state",
-      "processBundle: reducer state must not be undefined"
-    );
-    return draft;
-  }
-  const privateState = cloneProcessState(reduction.state);
-  if (!privateState.ok) {
-    emitProcessFailure(draft, emit, command, command, "malformed-state", privateState.message);
-    return draft;
-  }
-  const visibleState = cloneProcessState(privateState.value);
-  if (!visibleState.ok) {
-    emitProcessFailure(draft, emit, command, command, "malformed-state", visibleState.message);
-    return draft;
-  }
-  const preparedEvents = prepareProcessEvents(command, draft, reduction.events ?? []);
-  if (typeof preparedEvents === "string") {
-    emitProcessFailure(draft, emit, command, command, "malformed-event", preparedEvents);
-    return draft;
-  }
-  const preparedEffects = prepareProcessEffects(command, draft, reduction.effects ?? []);
-  if (typeof preparedEffects === "string") {
-    emitProcessFailure(draft, emit, command, command, "malformed-effect", preparedEffects);
-    return draft;
-  }
-  const timestampMs = readTimestampMs(now);
-  if (typeof timestampMs === "string") {
-    emitProcessFailure(draft, emit, command, command, "clock-threw", timestampMs);
-    return draft;
-  }
-  draft.state = privateState.value;
-  emit({ kind: "state", state: visibleState.value, cursor: processCursorOf(draft) });
-  const events = [];
-  for (const eventDraft of preparedEvents) {
-    draft.eventSeq += 1;
-    draft.seenEventIds.push(eventDraft.id);
-    const event = {
-      id: eventDraft.id,
-      type: eventDraft.type,
-      seq: draft.eventSeq,
-      cursor: draft.eventSeq,
-      commandId: command.id,
-      commandType: command.type,
-      payload: eventDraft.payload,
-      timestampMs,
-      ...eventDraft.processId === void 0 ? {} : { processId: eventDraft.processId },
-      ...eventDraft.correlationId === void 0 ? {} : { correlationId: eventDraft.correlationId },
-      ...eventDraft.causationId === void 0 ? {} : { causationId: eventDraft.causationId },
-      ...eventDraft.metadata === void 0 ? {} : { metadata: eventDraft.metadata }
-    };
-    events.push(event);
-    emit({ kind: "event", event });
-  }
-  const effects = [];
-  for (const effectDraft of preparedEffects) {
-    draft.effectSeq += 1;
-    draft.seenEffectIds.push(effectDraft.id);
-    const effect = {
-      id: effectDraft.id,
-      type: effectDraft.type,
-      seq: draft.effectSeq,
-      cursor: draft.effectSeq,
-      commandId: command.id,
-      commandType: command.type,
-      payload: effectDraft.payload,
-      timestampMs,
-      ...effectDraft.processId === void 0 ? {} : { processId: effectDraft.processId },
-      ...effectDraft.correlationId === void 0 ? {} : { correlationId: effectDraft.correlationId },
-      ...effectDraft.causationId === void 0 ? {} : { causationId: effectDraft.causationId },
-      ...effectDraft.metadata === void 0 ? {} : { metadata: effectDraft.metadata }
-    };
-    effects.push(effect);
-    emit({ kind: "effect-request", effect });
-  }
-  emitProcessStatus(draft, emit, command, "accepted", events.length, effects.length);
-  emitProcessAudit(draft, emit, command, "success", events, effects, void 0, void 0);
-  emit({ kind: "cursor", cursor: processCursorOf(draft) });
-  return draft;
-}
-function processProjection(graph, runtime, name, factory, select) {
-  return graph.node(
-    [runtime],
-    (ctx) => {
-      for (const raw of depBatch(ctx, 0) ?? []) {
-        const selected = select(raw);
-        if (selected !== void 0) ctx.down([["DATA", selected]]);
-      }
-    },
-    { name, factory, completeWhenDepsComplete: false, errorWhenDepsError: false }
-  );
-}
-function parseProcessCommand(value) {
-  if (!isObjectRecord(value)) return "processBundle: command fact must be an object";
-  if (typeof value.id !== "string" || value.id.length === 0) {
-    return "processBundle: command id must be a non-empty string";
-  }
-  if (typeof value.type !== "string" || value.type.length === 0) {
-    return "processBundle: command type must be a non-empty string";
-  }
-  return {
-    id: value.id,
-    type: value.type,
-    payload: value.payload,
-    ...typeof value.processId === "string" ? { processId: value.processId } : {},
-    ...typeof value.correlationId === "string" ? { correlationId: value.correlationId } : {},
-    ...typeof value.causationId === "string" ? { causationId: value.causationId } : {},
-    ...isObjectRecord(value.metadata) ? { metadata: value.metadata } : {}
-  };
-}
-function prepareProcessEvents(command, state, drafts) {
-  if (!Array.isArray(drafts)) return "processBundle: events must be an array";
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (let i = 0; i < drafts.length; i += 1) {
-    const draft = drafts[i];
-    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
-      return "processBundle: event draft must have a non-empty type";
-    }
-    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:event:${state.eventSeq + i + 1}`;
-    if (seen.has(id)) return `processBundle: duplicate event '${id}'`;
-    if (state.seenEventIds.includes(id)) return `processBundle: duplicate event '${id}'`;
-    seen.add(id);
-    out.push({
-      id,
-      type: draft.type,
-      payload: draft.payload,
-      ...typeof draft.processId === "string" ? { processId: draft.processId } : {},
-      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
-      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
-      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
-    });
-  }
-  return out;
-}
-function prepareProcessEffects(command, state, drafts) {
-  if (!Array.isArray(drafts)) return "processBundle: effects must be an array";
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (let i = 0; i < drafts.length; i += 1) {
-    const draft = drafts[i];
-    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
-      return "processBundle: effect draft must have a non-empty type";
-    }
-    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:effect:${state.effectSeq + i + 1}`;
-    if (seen.has(id)) return `processBundle: duplicate effect '${id}'`;
-    if (state.seenEffectIds.includes(id)) return `processBundle: duplicate effect '${id}'`;
-    seen.add(id);
-    out.push({
-      id,
-      type: draft.type,
-      payload: draft.payload,
-      ...typeof draft.processId === "string" ? { processId: draft.processId } : {},
-      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
-      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
-      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
-    });
-  }
-  return out;
-}
-function emitProcessFailure(state, emit, raw, command, code, message) {
-  state.errorCount += 1;
-  const cursor = processCursorOf(state);
-  const error = {
-    code,
-    message,
-    command: raw,
-    ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
-    cursor
-  };
-  emit({ kind: "error", error });
-  emitProcessStatus(state, emit, command, "rejected", 0, 0, code);
-  emitProcessAudit(state, emit, command, "failure", [], [], code, message);
-  emit({ kind: "cursor", cursor: processCursorOf(state) });
-}
-function emitProcessStatus(state, emit, command, statusState, eventCount, effectCount, errorCode) {
-  emit({
-    kind: "status",
-    status: {
-      state: statusState,
-      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
-      eventCount,
-      effectCount,
-      ...errorCode === void 0 ? {} : { errorCode },
-      cursor: processCursorOf(state)
-    }
-  });
-}
-function emitProcessAudit(state, emit, command, outcome, events, effects, errorCode, errorMessage2) {
-  state.auditSeq += 1;
-  emit({
-    kind: "audit",
-    audit: {
-      seq: state.auditSeq,
-      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
-      outcome,
-      eventIds: events.map((event) => event.id),
-      eventTypes: events.map((event) => event.type),
-      effectIds: effects.map((effect) => effect.id),
-      effectTypes: effects.map((effect) => effect.type),
-      ...errorCode === void 0 ? {} : { errorCode },
-      ...errorMessage2 === void 0 ? {} : { errorMessage: errorMessage2 },
-      cursor: processCursorOf(state)
-    }
-  });
-}
-function processCursorOf(state) {
-  return {
-    eventSeq: state.eventSeq,
-    effectSeq: state.effectSeq,
-    commandCount: state.commandCount,
-    errorCount: state.errorCount,
-    auditSeq: state.auditSeq
-  };
-}
-function cloneProcessState(state) {
-  if (typeof state !== "object" || state === null) return { ok: true, value: state };
-  try {
-    if (typeof globalThis.structuredClone === "function") {
-      return { ok: true, value: globalThis.structuredClone(state) };
-    }
-    return { ok: true, value: JSON.parse(JSON.stringify(state)) };
-  } catch (error) {
-    return {
-      ok: false,
-      message: `processBundle: state must be cloneable before reducer execution (${errorMessage(error)})`
-    };
-  }
-}
-function readTimestampMs(now) {
-  try {
-    const timestampMs = now();
-    if (!Number.isFinite(timestampMs)) return "processBundle: now() must return a finite number";
-    return timestampMs;
-  } catch (error) {
-    return errorMessage(error);
-  }
-}
-function rethrowGraphRuntimeInvariant(error) {
-  const message = errorMessage(error);
-  if (message.includes("R-reentrancy") || message.includes("R-rewire") || message.includes("R-graph-domain") || message.includes("D37") || message.includes("D22") || message.includes("different graph") || message.includes("cross-graph") || message.includes("wire bridge") || message.includes("mid-fn topology mutation") || message.includes("reentrant dep mutation") || message.includes("feedback cycle")) {
-    throw error;
-  }
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
+import "../chunk-CX6B6PO2.js";
+import "../chunk-CJIFGJQG.js";
+import "../chunk-SHZDP2MQ.js";
+import "../chunk-WQIA3GFB.js";
+import "../chunk-S6HXABGL.js";
+import "../chunk-K7FB3JTD.js";
+import "../chunk-DGUM43GV.js";
 export {
+  admitAgentRequestProposal,
+  agentRequestLedgerViews,
+  agentRequestProposalFromDecision,
   backoffDelayMs,
   breakerBundle,
+  buildToolProviderAdapterInputs,
+  buildToolProviderExecutorOutcome,
   constantBackoff,
+  effectRun,
+  effectRunCompletionProjector,
+  executorOutcomeViewProjector,
+  fakeExecutorBlocked,
+  fakeExecutorCanceled,
+  fakeExecutorFailure,
+  fakeExecutorResult,
+  fakeExecutorTimeout,
+  issueAgentRequest,
+  localBuiltinToolProviderCatalog,
   nextRetryDelayMs,
   noBackoff,
   processBundle,
   processEffectRunner,
   rateLimitBundle,
+  requestSatisfactionProjector,
+  requestToolProviderAdapterRun,
+  resolveToolProviderExecutionPolicies,
   retryPolicy,
   retryStatusBundle,
+  scheduledReadinessProjector,
   shouldRetry,
-  timeoutBundle
+  structuredAgentDecisionInterpreter,
+  timeoutBundle,
+  toolProviderAdapterInputProjector,
+  toolProviderAdapterRunProjector,
+  toolProviderPolicyResolutionProjector,
+  toolProviderRunAdmissionProjector,
+  toolProviderRunRetryProjector,
+  validateToolProviderExecutionPolicy
 };
 //# sourceMappingURL=index.js.map