@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/presets/ai/index.d.cts

@@ -0,0 +1,98 @@
+export { A as AgentBundle, a as AgentGraph, b as AgentLoopGraph, c as AgentLoopOptions, d as AgentLoopStatus, e as AgentMemoryGraph, f as AgentMemoryOptions, g as AgentSpec, h as AgentStatus, C as CostState, P as PresetRegistryBundle, Z as ZERO_COST, i as addUsage, j as agent, k as agentLoop, l as agentMemory, p as presetRegistry } from '../../agents-C0Ji9ldU.cjs';
+export { C as CompressionCache, a as CompressionRule, b as ContextEntry, c as ContextView, L as LlmCompress, P as PoolGCPolicy, R as RenderedEntry, d as RuleMatch, T as Tag, e as TaggedContextPoolBundle, f as TaggedContextPoolOptions, g as Tier, r as renderContextView, t as taggedContextPool, h as tierCompress } from '../../index-DLAxYaN5.cjs';
+import { Node } from '@graphrefly/pure-ts/core';
+import { Graph } from '@graphrefly/pure-ts/graph';
+import { L as LLMAdapter } from '../../types-BB5Lw-pB.cjs';
+export { q as ToolResult } from '../../memory-composers-BryDrRBX.cjs';
+import '@graphrefly/pure-ts/extra';
+import '../../distill-De6Rnn15.cjs';
+import '../../utils/memory/index.cjs';
+import '../../base/mutation/index.cjs';
+import '../../_internal-B23BagFd.cjs';
+
+/**
+ * DS-14.6.A U-C — `heterogeneousDebate()` (Phase 14.5).
+ *
+ * Stanford-MAD heterogeneity thesis (SESSION-DS-14.6-A L9): participants get
+ * **different model adapters + different role prompts**. Closed reasoning
+ * loop — no tools / side effects / persistent state beyond the transcript.
+ *
+ * **Reactive topology (QA M1→b, 2026-05-15).** The round loop is NOT a
+ * top-level `async while` driver. It mirrors `refineLoop`'s §7 feedback
+ * shape so `describe()` / `explain()` / dry-run see the structure:
+ *
+ * ```
+ *   roundTrigger(state) ──▶ roundWork(switchMap→producer, per-round
+ *                            sequential adapter.invoke) ──▶ transcript(scan)
+ *                            └─▶ converged(derived)              │
+ *        ▲                                                       │
+ *        └────────────  decideEffect (feedback + trigger)  ◀─────┘
+ * ```
+ *
+ * The per-round participant calls are an async **source boundary** inside
+ * the switchMap producer (spec §5.10 — async belongs in sources), with an
+ * abort-on-deactivate `AbortController` (COMPOSITION-GUIDE §45) so a
+ * superseded / torn-down round cancels its in-flight LLM calls. `decideEffect`
+ * is the sole feedback authority (computes termination inline from the round
+ * envelope + closure history, §28); `converged` is a parallel derived purely
+ * for external `status` observability. Termination: `fixedRounds |
+ * "until-converge" | { until: Node<boolean> }` — `until` is a real reactive
+ * dep, not a `.cache` poll. `"until-converge"` uses a pluggable `converge?`
+ * fn, default = no participant changed stance across the last 2 rounds
+ * (D-C1, zero extra LLM cost). `output:"synthesizer-final"` with no
+ * synthesizer-role participant throws at construction (D-C2).
+ *
+ * @module
+ */
+
+interface Turn {
+    readonly round: number;
+    readonly role: string;
+    readonly content: string;
+}
+interface DebateParticipant {
+    readonly adapter: LLMAdapter;
+    /** e.g. "advocate" | "skeptic" | "synthesizer" | custom. */
+    readonly role: string;
+    readonly systemPrompt: string;
+}
+type DebateTermination = number | "until-converge" | {
+    readonly until: Node<boolean>;
+};
+type DebateOutput = "transcript" | "synthesizer-final" | {
+    readonly project: (transcript: readonly Turn[]) => unknown;
+};
+type DebateStatus = "running" | "converged" | "max-rounds" | "error";
+interface HeterogeneousDebateOptions {
+    readonly question: string;
+    readonly participants: readonly DebateParticipant[];
+    /** Default `3`. */
+    readonly rounds?: DebateTermination;
+    /** Default `"transcript"`. */
+    readonly output?: DebateOutput;
+    /**
+     * D-C1 — `"until-converge"` detector. Default: no participant's latest
+     * content changed vs the previous round (structural compare, no LLM).
+     */
+    readonly converge?: (transcript: readonly Turn[]) => boolean;
+    readonly name?: string;
+    /** Hard ceiling for `"until-converge"` / `{ until }` (default 12). */
+    readonly maxRounds?: number;
+}
+interface HeterogeneousDebateBundle {
+    readonly transcript: Node<readonly Turn[]>;
+    readonly result: Node<unknown>;
+    readonly status: Node<DebateStatus>;
+    readonly graph: DebateGraph;
+    /**
+     * Thin `awaitSettled` bridge (mirrors `agentLoop.run()`): kicks the
+     * reactive round loop and resolves the final `result`. Throws
+     * `RangeError` if a prior `run()` is still pending (QA P4 re-entrancy).
+     */
+    run(): Promise<unknown>;
+}
+declare class DebateGraph extends Graph {
+}
+declare function heterogeneousDebate(parent: Graph, opts: HeterogeneousDebateOptions): HeterogeneousDebateBundle;
+
+export { DebateGraph, type DebateOutput, type DebateParticipant, type DebateStatus, type DebateTermination, type HeterogeneousDebateBundle, type HeterogeneousDebateOptions, type Turn, heterogeneousDebate };

package/dist/presets/ai/index.d.ts

@@ -0,0 +1,98 @@
+export { A as AgentBundle, a as AgentGraph, b as AgentLoopGraph, c as AgentLoopOptions, d as AgentLoopStatus, e as AgentMemoryGraph, f as AgentMemoryOptions, g as AgentSpec, h as AgentStatus, C as CostState, P as PresetRegistryBundle, Z as ZERO_COST, i as addUsage, j as agent, k as agentLoop, l as agentMemory, p as presetRegistry } from '../../agents-C9zexT7I.js';
+export { C as CompressionCache, a as CompressionRule, b as ContextEntry, c as ContextView, L as LlmCompress, P as PoolGCPolicy, R as RenderedEntry, d as RuleMatch, T as Tag, e as TaggedContextPoolBundle, f as TaggedContextPoolOptions, g as Tier, r as renderContextView, t as taggedContextPool, h as tierCompress } from '../../index-DLAxYaN5.js';
+import { Node } from '@graphrefly/pure-ts/core';
+import { Graph } from '@graphrefly/pure-ts/graph';
+import { L as LLMAdapter } from '../../types-BB5Lw-pB.js';
+export { q as ToolResult } from '../../memory-composers-CVQqPYEV.js';
+import '@graphrefly/pure-ts/extra';
+import '../../distill-De6Rnn15.js';
+import '../../utils/memory/index.js';
+import '../../base/mutation/index.js';
+import '../../_internal-B23BagFd.js';
+
+/**
+ * DS-14.6.A U-C — `heterogeneousDebate()` (Phase 14.5).
+ *
+ * Stanford-MAD heterogeneity thesis (SESSION-DS-14.6-A L9): participants get
+ * **different model adapters + different role prompts**. Closed reasoning
+ * loop — no tools / side effects / persistent state beyond the transcript.
+ *
+ * **Reactive topology (QA M1→b, 2026-05-15).** The round loop is NOT a
+ * top-level `async while` driver. It mirrors `refineLoop`'s §7 feedback
+ * shape so `describe()` / `explain()` / dry-run see the structure:
+ *
+ * ```
+ *   roundTrigger(state) ──▶ roundWork(switchMap→producer, per-round
+ *                            sequential adapter.invoke) ──▶ transcript(scan)
+ *                            └─▶ converged(derived)              │
+ *        ▲                                                       │
+ *        └────────────  decideEffect (feedback + trigger)  ◀─────┘
+ * ```
+ *
+ * The per-round participant calls are an async **source boundary** inside
+ * the switchMap producer (spec §5.10 — async belongs in sources), with an
+ * abort-on-deactivate `AbortController` (COMPOSITION-GUIDE §45) so a
+ * superseded / torn-down round cancels its in-flight LLM calls. `decideEffect`
+ * is the sole feedback authority (computes termination inline from the round
+ * envelope + closure history, §28); `converged` is a parallel derived purely
+ * for external `status` observability. Termination: `fixedRounds |
+ * "until-converge" | { until: Node<boolean> }` — `until` is a real reactive
+ * dep, not a `.cache` poll. `"until-converge"` uses a pluggable `converge?`
+ * fn, default = no participant changed stance across the last 2 rounds
+ * (D-C1, zero extra LLM cost). `output:"synthesizer-final"` with no
+ * synthesizer-role participant throws at construction (D-C2).
+ *
+ * @module
+ */
+
+interface Turn {
+    readonly round: number;
+    readonly role: string;
+    readonly content: string;
+}
+interface DebateParticipant {
+    readonly adapter: LLMAdapter;
+    /** e.g. "advocate" | "skeptic" | "synthesizer" | custom. */
+    readonly role: string;
+    readonly systemPrompt: string;
+}
+type DebateTermination = number | "until-converge" | {
+    readonly until: Node<boolean>;
+};
+type DebateOutput = "transcript" | "synthesizer-final" | {
+    readonly project: (transcript: readonly Turn[]) => unknown;
+};
+type DebateStatus = "running" | "converged" | "max-rounds" | "error";
+interface HeterogeneousDebateOptions {
+    readonly question: string;
+    readonly participants: readonly DebateParticipant[];
+    /** Default `3`. */
+    readonly rounds?: DebateTermination;
+    /** Default `"transcript"`. */
+    readonly output?: DebateOutput;
+    /**
+     * D-C1 — `"until-converge"` detector. Default: no participant's latest
+     * content changed vs the previous round (structural compare, no LLM).
+     */
+    readonly converge?: (transcript: readonly Turn[]) => boolean;
+    readonly name?: string;
+    /** Hard ceiling for `"until-converge"` / `{ until }` (default 12). */
+    readonly maxRounds?: number;
+}
+interface HeterogeneousDebateBundle {
+    readonly transcript: Node<readonly Turn[]>;
+    readonly result: Node<unknown>;
+    readonly status: Node<DebateStatus>;
+    readonly graph: DebateGraph;
+    /**
+     * Thin `awaitSettled` bridge (mirrors `agentLoop.run()`): kicks the
+     * reactive round loop and resolves the final `result`. Throws
+     * `RangeError` if a prior `run()` is still pending (QA P4 re-entrancy).
+     */
+    run(): Promise<unknown>;
+}
+declare class DebateGraph extends Graph {
+}
+declare function heterogeneousDebate(parent: Graph, opts: HeterogeneousDebateOptions): HeterogeneousDebateBundle;
+
+export { DebateGraph, type DebateOutput, type DebateParticipant, type DebateStatus, type DebateTermination, type HeterogeneousDebateBundle, type HeterogeneousDebateOptions, type Turn, heterogeneousDebate };

package/dist/presets/ai/index.js

@@ -0,0 +1,54 @@
+import {
+  DebateGraph,
+  heterogeneousDebate
+} from "../../chunk-E5OZPDIW.js";
+import {
+  CompressionCache,
+  renderContextView,
+  taggedContextPool,
+  tierCompress
+} from "../../chunk-KIIXR252.js";
+import {
+  AgentMemoryGraph,
+  agentMemory
+} from "../../chunk-WKSWLSCX.js";
+import {
+  AgentGraph,
+  AgentLoopGraph,
+  ZERO_COST,
+  addUsage,
+  agent,
+  agentLoop,
+  presetRegistry
+} from "../../chunk-5THCXDWY.js";
+import "../../chunk-OO5BM6CJ.js";
+import "../../chunk-FR6RGA3B.js";
+import "../../chunk-Q3EYOCZB.js";
+import "../../chunk-QMBYUVRL.js";
+import "../../chunk-FMPF42Q4.js";
+import "../../chunk-BXGZFGZ4.js";
+import "../../chunk-A7KV5UK4.js";
+import "../../chunk-DKNHAICT.js";
+import "../../chunk-O3MT7DYI.js";
+import "../../chunk-Z4YXAUDN.js";
+import "../../chunk-TSBFTJKM.js";
+import "../../chunk-P5LBT622.js";
+import "../../chunk-AZDQPQ3V.js";
+export {
+  AgentGraph,
+  AgentLoopGraph,
+  AgentMemoryGraph,
+  CompressionCache,
+  DebateGraph,
+  ZERO_COST,
+  addUsage,
+  agent,
+  agentLoop,
+  agentMemory,
+  heterogeneousDebate,
+  presetRegistry,
+  renderContextView,
+  taggedContextPool,
+  tierCompress
+};
+//# sourceMappingURL=index.js.map

package/dist/presets/ai/index.js.map

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