@hicaru/pi-rlm 0.1.0 → 0.1.2

package/src/tool/repl-tool.ts

@@ -24,10 +24,10 @@ import { previewText } from "../text/preview.ts";
 import { mapPool } from "../util/concurrency.ts";
 import { LimitGuard } from "../core/limits.ts";
 import { checkResourceLimits } from "../core/resource-limits.ts";
-import type { RlmConfig, Sampling } from "../core/types.ts";
+import type { InteractiveDeps, RlmConfig, Sampling } from "../core/types.ts";
 import { SandboxManager } from "../sandbox/sandbox-manager.ts";
 import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
-import type { ReplResult } from "../sandbox/protocol.ts";
+import type { ProposedEdit, ReplResult } from "../sandbox/protocol.ts";
 import { RlmEmitter } from "./rlm-events.ts";
 import { SubcallStore } from "./subcall-store.ts";
 import type { ReplDetails } from "./repl-details.ts";
@@ -47,6 +47,10 @@ export const ReplToolParams = Object.freeze(Type.Object({
   code: Type.String({ description: "Python code to execute in the persistent REPL sandbox" }),
 }));
 
+export function surfaceReplEdits(edits: readonly ProposedEdit[], raised: boolean): readonly ProposedEdit[] | undefined {
+  return edits.length > 0 && !raised ? edits : undefined;
+}
+
 // ── Mutable bridge state (handler indirection) ──
 
 /**
@@ -60,12 +64,14 @@ class NativeBridgeState {
   currentParentId: string | undefined;
   currentDepth = 0;
   currentLimits: LimitGuard | null = null;
+  currentInteractive: InteractiveDeps | null = null;
 
-  swap(inv: { emitter: RlmEmitter; parentId?: string; depth: number; limits: LimitGuard }): void {
+  swap(inv: { emitter: RlmEmitter; parentId?: string; depth: number; limits: LimitGuard; interactive: InteractiveDeps }): void {
     this.currentEmitter = inv.emitter;
     this.currentParentId = inv.parentId;
     this.currentDepth = inv.depth;
     this.currentLimits = inv.limits;
+    this.currentInteractive = inv.interactive;
   }
 
   buildLlmHandlers(deps: {
@@ -220,6 +226,8 @@ class NativeBridgeState {
           maxTokens: deps.config.maxTokens,
           maxErrors: deps.config.maxErrors,
         },
+        onTodo: state.currentInteractive?.onTodo,
+        onAskUserQuestion: state.currentInteractive?.onAskUserQuestion,
       });
 
       try {
@@ -273,6 +281,7 @@ export interface ReplToolDeps {
   readonly config: RlmConfig;
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
+  readonly ensureContext?: () => Promise<void>;
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
@@ -374,6 +383,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           parentId: undefined,
         });
 
+        await deps.ensureContext?.();
         await sandboxManager.getOrCreate({
           ...llmHandlers,
           ...rlmHandlers,
@@ -395,7 +405,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           // Wire per-invocation mutable state only after the serialized exec slot
           // is active. Swapping earlier would let queued repl() calls overwrite
           // emitter/limits for the currently running REPL execution.
-          bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits });
+          bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits, interactive });
         });
         const elapsed = Date.now() - start;
         capturedStdout = result.stdout;
@@ -411,6 +421,12 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
 
         if (queuedId) emitter.emitSubcallUpdated({ id: queuedId, status: "done" });
 
+        const baseText = result.stdout || result.answerContent || "(no output)";
+        const surfacedEdits = surfaceReplEdits(result.edits, result.raised);
+        const editsBlock = surfacedEdits
+          ? `\n\nSTAGED_EDITS:\n${JSON.stringify(surfacedEdits)}`
+          : "";
+
         const details: ReplDetails = {
           status: "done",
           output: result.stdout,
@@ -418,10 +434,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           executionTimeMs: elapsed,
           subcalls: store.getSubcalls(),
           totals: store.getTotals(),
+          edits: surfacedEdits,
         };
         // Final progressive update
         onUpdate?.({ content: [{ type: "text", text: result.stdout.slice(0, 500) || "(no output)" }], details });
-        return { content: [{ type: "text", text: result.stdout || result.answerContent || "(no output)" }], details };
+        return { content: [{ type: "text", text: baseText + editsBlock }], details };
       } catch (e) {
         progressStatus = "error";
         const msg = errorMessage(e);
@@ -477,6 +494,9 @@ function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
   parts.push(formatCost(details.totals.costUsd));
   if (details.totals.tokens > 0) parts.push(`${formatTokens(details.totals.tokens)} tok`);
   if (details.executionTimeMs > 0) parts.push(`${details.executionTimeMs}ms`);
+  if (details.edits && details.edits.length > 0) {
+    parts.push(theme.fg("success", `${details.edits.length} staged`));
+  }
   const stats = parts.length > 0 ? ` ${theme.fg("dim", parts.join(" · "))}` : "";
 
   const header = `${glyph} ${theme.fg("toolTitle", theme.bold("REPL"))}${stats}`;
@@ -511,6 +531,15 @@ function renderReplExpanded(details: ReplDetails, theme: Theme): Container {
     container.addChild(new Text(out, 0, 0));
   }
 
+  if (details.edits && details.edits.length > 0) {
+    const editFiles = new Set<string>();
+    for (const edit of details.edits) editFiles.add(edit.path);
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("success",
+      `${details.edits.length} edit${details.edits.length > 1 ? "s" : ""} staged across ${editFiles.size} file${editFiles.size > 1 ? "s" : ""}`,
+    ), 0, 0));
+  }
+
   // Stderr
   if (details.stderr) {
     container.addChild(new Spacer(1));

package/src/tool/rlm-events.ts

@@ -2,8 +2,8 @@
  * RlmEmitter — typed EventEmitter wrapper for RLM lifecycle events.
  *
  * Replaces RlmToolBridge mutation methods. The engine and bridges emit typed
- * events instead of calling bridge.addSubcall/updateSubcall/etc. Listeners
- * (RlmEventAggregator, TelemetrySink) subscribe to build derived state.
+ * events instead of calling bridge.addSubcall/updateSubcall/etc. The
+ * RlmEventAggregator subscribes to build derived state.
  *
  * Node.js EventEmitter is synchronous — listeners run in registration order
  * during emit. No backpressure needed: engine events are sequential, one at
@@ -11,7 +11,6 @@
  */
 
 import { EventEmitter } from "node:events";
-import type { TelemetrySink } from "../telemetry/sink.ts";
 import type { SubcallKind, SubcallStatus, RlmRunStatus } from "./rlm-details.ts";
 import type { ProposedEdit } from "../sandbox/protocol.ts";
 
@@ -76,7 +75,6 @@ export interface RootPromptEvent {
  *
  * Auto-generates monotonic subcall IDs (`s1`, `s2`, …) via `emitSubcallCreated()`.
  * Provides typed `on*` methods that return unsubscribe functions.
- * `attachSink()` wires all events to a TelemetrySink and returns a detach function.
  */
 export class RlmEmitter {
   private readonly ee = new EventEmitter();
@@ -169,43 +167,6 @@ export class RlmEmitter {
     return () => { this.ee.off("root-prompt", handler); };
   }
 
-  // ── Sink integration ──
-
-  /**
-   * Wire all lifecycle events to a TelemetrySink.
-   * Returns a detach function that unsubscribes all sink listeners.
-   * The caller is responsible for calling `sink.shutdown()` after detaching.
-   */
-  attachSink(sink: TelemetrySink): () => void {
-    const unsubs: (() => void)[] = [];
-
-    unsubs.push(this.onSubcallCreated((event) => {
-      sink.start(event.id, {
-        kind: event.kind,
-        depth: event.depth,
-        parentId: event.parentId,
-        model: event.model,
-        label: event.label,
-        detail: event.detail,
-        args: event.args,
-      });
-    }));
-
-    unsubs.push(this.onSubcallUpdated((event) => {
-      if (event.costUsd !== undefined || event.tokens !== undefined) {
-        sink.usage(event.id, event.costUsd ?? 0, event.tokens ?? 0);
-      }
-      if (event.status !== undefined && event.status !== "running") {
-        sink.end(event.id, {
-          error: event.status === "error" ? (event.detail ?? "error") : undefined,
-          resultPreview: event.resultPreview,
-        });
-      }
-    }));
-
-    return () => { unsubs.forEach((fn) => fn()); };
-  }
-
   // ── Lifecycle ──
 
   /** Remove all listeners. Call after the run completes to prevent leaks. */

package/src/tool/rlm-tool.ts

@@ -11,7 +11,6 @@ import { Container, Markdown, Spacer, Text, type Component } from "@earendil-wor
 import { Type } from "typebox";
 import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
 import type { RlmController, StartInput } from "../mode/rlm-mode.ts";
-import { createTelemetrySink } from "../telemetry/index.ts";
 import { formatCost, formatTokens, spinnerFrame } from "../ui/theme.ts";
 import { errorMessage } from "../util/errors.ts";
 import { type RlmDetails } from "./rlm-details.ts";
@@ -23,8 +22,6 @@ import {
   renderExpandedSubcallTree,
 } from "./subcall-render.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
-import { applyEdits } from "../patch/index.ts";
-import { tryExtractDiff } from "../core/answer.ts";
 
 // ── Parameter schema ──
 
@@ -63,11 +60,8 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
       if (!validation.ok) return validation.error;
       const params = validation.value;
 
-      const sink = await createTelemetrySink(controller.config.telemetry);
       const emitter = new RlmEmitter();
       const aggregator = new RlmEventAggregator(emitter, onUpdate ?? (() => {}));
-      let detachSink: (() => void) | undefined;
-      if (sink) detachSink = emitter.attachSink(sink);
       emitter.emitRootPrompt(params.prompt);
 
       // Wire abort signal to controller
@@ -98,10 +92,6 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
         const result = await done;
 
         emitter.emitAnswer(result.answer);
-        const proposedEdits = result.edits ?? [];
-        const proposedDiffs = result.diffs?.length ? result.diffs : tryExtractDiff(result.answer);
-        if (proposedEdits.length > 0) emitter.emitEdits(proposedEdits);
-        await applyEdits(proposedEdits, proposedDiffs, ctx);
 
         return {
           content: [{ type: "text", text: result.answer }],
@@ -116,11 +106,8 @@ export function createRlmTool(controller: RlmController): ToolDefinition<typeof
         };
       } finally {
         progress.stop();
-        detachSink?.();
         aggregator.dispose();
         emitter.shutdown();
-        try { await sink?.shutdown(); }
-        catch (err) { console.warn(`[rlm] telemetry shutdown failed: ${errorMessage(err)}`); }
       }
     },
 

package/src/ui/model-picker.ts

@@ -14,12 +14,19 @@ export interface ModelSelection {
 const LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 type SelectableThinkingLevel = (typeof LEVELS)[number];
 
-function items(models: Model<Api>[]): SelectItem[] {
-  return models.map((m) => ({
+const CHEAPEST_VALUE = "__rlm_cheapest__";
+
+function items(models: Model<Api>[], includeCheapest = false): SelectItem[] {
+  const modelItems = models.map((m) => ({
     value: `${m.provider}/${m.id}`,
     label: `${m.provider}/${m.id}`,
     description: `in ${formatCost(m.cost.input)}/Mtok · out ${formatCost(m.cost.output)}/Mtok${m.reasoning ? " · reasoning" : ""}`,
   }));
+  if (!includeCheapest) return modelItems;
+  return [
+    { value: CHEAPEST_VALUE, label: "⟳ cheapest (auto)", description: "Always use the cheapest available model" },
+    ...modelItems,
+  ];
 }
 
 function supportedThinkingLevels(model: Model<Api>): SelectableThinkingLevel[] {
@@ -75,7 +82,7 @@ export async function selectModel(
   models: Model<Api>[],
   current?: Model<Api>,
   currentThinking?: ThinkingLevel,
-): Promise<ModelSelection | undefined> {
+): Promise<ModelSelection | null | undefined> {
   if (models.length === 0) {
     ctx.ui.notify("RLM: no models with configured auth", "warning");
     return undefined;
@@ -96,7 +103,7 @@ export async function selectModel(
       render: (w) => [truncateToWidth(theme.fg("dim", `Filter: ${query || "type to filter…"}`), w)],
       invalidate: () => {},
     };
-    const list = new SelectList(items(models), Math.min(models.length, 12), {
+    const list = new SelectList(items(models, true), Math.min(models.length + 1, 13), {
       selectedPrefix: (t) => theme.fg("accent", t),
       selectedText: (t) => theme.fg("accent", t),
       description: (t) => theme.fg("muted", t),
@@ -133,6 +140,7 @@ export async function selectModel(
     };
   });
 
+  if (chosen === CHEAPEST_VALUE) return null;
   const model = chosen ? models.find((m) => `${m.provider}/${m.id}` === chosen) : undefined;
   if (!model) return undefined;
   return { model, thinkingLevel: await selectThinkingLevel(ctx, model, currentThinking) };

package/src/patch/apply.ts

@@ -1,148 +0,0 @@
-/**
- * Applies RLM-proposed edits to disk.
- *
- * Two edit kinds from the sandbox protocol:
- *   ProposedEdit      — oldText / newText anchor replacement
- *   ProposedDiffEdit  — unified diff string (applied via `diff.applyPatch`)
- *
- * Returns a Result. Caller decides whether to show errors in UI.
- */
-
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import * as Diff from "diff";
-import type { ProposedDiffEdit, ProposedEdit } from "../sandbox/protocol.ts";
-import { err, ok, type Result } from "../util/errors.ts";
-
-// ── Shared private helpers ─────────────────────────────────────────────────
-
-/** Normalise to LF so string-replace is CRLF-safe. */
-function toLF(s: string): string {
-  return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-/** Restore original line endings after replacement. */
-function restoreEndings(s: string, crlf: boolean): string {
-  return crlf ? s.replace(/\n/g, "\r\n") : s;
-}
-
-function hasCRLF(s: string): boolean {
-  return s.includes("\r\n");
-}
-
-// ── ApplyResult ─────────────────────────────────────────────────────────────
-
-export interface ApplySuccess {
-  readonly applied: number;
-}
-
-export interface ApplyFailure {
-  readonly failures: ReadonlyArray<{ readonly path: string; readonly reason: string }>;
-}
-
-export type ApplyResult = Result<ApplySuccess, ApplyFailure>;
-
-// ── Generic accumulator (shared by anchor + diff apply) ─────────────────────
-
-/**
- * Runs `applyOne` for every item, tallying successes and collecting failures.
- * The only thing that differs between anchor and diff apply is the per-item
- * helper and the failure-path key — both passed in, so the loop is written once.
- */
-async function applyAll<T>(
-  items: readonly T[],
-  applyOne: (item: T, cwd: string) => Promise<Result<void, string>>,
-  getKey: (item: T) => string,
-  cwd: string,
-): Promise<ApplyResult> {
-  const failures: Array<{ readonly path: string; readonly reason: string }> = [];
-  let applied = 0;
-  for (const item of items) {
-    const r = await applyOne(item, cwd);
-    if (r.ok) {
-      applied++;
-    } else {
-      failures.push({ path: getKey(item), reason: r.error });
-    }
-  }
-  return failures.length === 0 ? ok({ applied }) : err({ failures });
-}
-
-// ── ProposedEdit (oldText / newText) ────────────────────────────────────────
-
-async function applySingleAnchor(
-  edit: ProposedEdit,
-  cwd: string,
-): Promise<Result<void, string>> {
-  const abs = resolve(cwd, edit.path);
-  let raw: string;
-  try {
-    raw = await readFile(abs, "utf8");
-  } catch (e) {
-    return err(`read error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const crlf = hasCRLF(raw);
-  const content = toLF(raw);
-  const needle = toLF(edit.oldText);
-  if (!content.includes(needle)) {
-    return err(`oldText not found in ${edit.path}`);
-  }
-  const replaced = content.replace(needle, toLF(edit.newText));
-  try {
-    await writeFile(abs, restoreEndings(replaced, crlf), "utf8");
-    return ok(undefined);
-  } catch (e) {
-    return err(`write error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-}
-
-export function applyAnchorEdits(
-  edits: readonly ProposedEdit[],
-  cwd: string,
-): Promise<ApplyResult> {
-  return applyAll(edits, applySingleAnchor, (e) => e.path, cwd);
-}
-
-// ── ProposedDiffEdit (unified diff string) ──────────────────────────────────
-
-async function applySingleDiff(
-  diffEdit: ProposedDiffEdit,
-  cwd: string,
-): Promise<Result<void, string>> {
-  // Extract file path from diff header: "--- a/path" or "--- path"
-  const match = /^--- (?:a\/)?(.+)$/m.exec(diffEdit.diff);
-  const relPath = match?.[1]?.trim();
-  if (relPath === undefined) {
-    return err("diff has no '---' header; cannot determine target file");
-  }
-  const abs = resolve(cwd, relPath);
-  let raw: string;
-  try {
-    raw = await readFile(abs, "utf8");
-  } catch (e) {
-    return err(`read error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const crlf = hasCRLF(raw);
-  let patched: string | false;
-  try {
-    patched = Diff.applyPatch(toLF(raw), diffEdit.diff);
-  } catch (e) {
-    return err(`invalid diff — ${e instanceof Error ? e.message : String(e)}`);
-  }
-  if (patched === false) {
-    return err(`patch does not apply cleanly to ${relPath}`);
-  }
-  try {
-    await writeFile(abs, restoreEndings(patched, crlf), "utf8");
-    return ok(undefined);
-  } catch (e) {
-    return err(`write error: ${e instanceof Error ? e.message : String(e)}`);
-  }
-}
-
-export function applyDiffEdits(
-  diffs: readonly ProposedDiffEdit[],
-  cwd: string,
-): Promise<ApplyResult> {
-  return applyAll(diffs, applySingleDiff, (d) => d.diff.slice(0, 40), cwd);
-}

package/src/patch/index.ts

@@ -1,37 +0,0 @@
-/**
- * applyEdits — THE single call site for applying proposed edits/diffs.
- *
- * Both rlm-tool.ts and rlm.ts must call this and nothing else.
- * No duplication allowed.
- */
-
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ProposedDiffEdit, ProposedEdit } from "../sandbox/protocol.ts";
-import { applyAnchorEdits, applyDiffEdits, type ApplyResult } from "./apply.ts";
-
-/** Surface an apply outcome through a single notify — used for both edit kinds. */
-function notifyApplyResult(r: ApplyResult, label: string, ctx: ExtensionContext): void {
-  if (!r.ok) {
-    const lines = r.error.failures.map((f) => `• ${f.path}: ${f.reason}`);
-    ctx.ui.notify(`Some ${label}s failed:\n${lines.join("\n")}`, "error");
-  } else {
-    ctx.ui.notify(`Applied ${r.value.applied} ${label}${r.value.applied !== 1 ? "s" : ""}.`, "info");
-  }
-}
-
-export async function applyEdits(
-  edits: readonly ProposedEdit[],
-  diffs: readonly ProposedDiffEdit[],
-  ctx: ExtensionContext,
-): Promise<void> {
-  const hasEdits = edits.length > 0 || diffs.length > 0;
-  if (!hasEdits) return;
-  const cwd = ctx.cwd ?? process.cwd();
-
-  if (edits.length > 0) {
-    notifyApplyResult(await applyAnchorEdits(edits, cwd), "edit", ctx);
-  }
-  if (diffs.length > 0) {
-    notifyApplyResult(await applyDiffEdits(diffs, cwd), "diff", ctx);
-  }
-}

package/src/state/events.ts

@@ -1,22 +0,0 @@
-/**
- * SubcallStart — parameter object carried forward for telemetry compatibility.
- *
- * The SubcallObserver interface, treeObserver(), observerWith(), and NOOP_OBSERVER
- * have been removed. The engine and bridges now call RlmToolBridge directly.
- */
-
-import type { SubcallKind } from "../tool/rlm-details.ts";
-
-export interface SubcallStart {
-  readonly kind: SubcallKind;
-  readonly depth: number;
-  readonly parentId?: string;
-  readonly model?: string;
-  readonly label: string;
-  readonly detail?: string;
-  readonly args?: string;
-  /** Run ID for the root node — lets MLflow correlate a resumed trace with the original. */
-  readonly runId?: string;
-  /** True when this is a resumed root node (not a fresh start). */
-  readonly resume?: boolean;
-}

package/src/telemetry/dispatcher.ts

@@ -1,116 +0,0 @@
-export interface DispatcherSink<E> {
-  readonly name: string;
-  handle(event: E): Promise<void>;
-  flush(): Promise<void>;
-  shutdown(): Promise<void>;
-}
-
-export interface DispatcherOptions {
-  readonly maxQueueSize: number;
-}
-
-/** Bounded FIFO async dispatcher with drop-oldest backpressure. */
-export class Dispatcher<E> {
-  private readonly sinks: DispatcherSink<E>[] = [];
-  private queue: E[] = [];
-  private flushing = false;
-  private inFlight: Promise<void> = Promise.resolve();
-  private shuttingDown = false;
-  private backpressureActive = false;
-  private readonly failed = new Set<string>();
-
-  constructor(private readonly options: DispatcherOptions) {}
-
-  registerSink(sink: DispatcherSink<E>): () => void {
-    this.sinks.push(sink);
-    return () => {
-      const idx = this.sinks.indexOf(sink);
-      if (idx >= 0) this.sinks.splice(idx, 1);
-    };
-  }
-
-  dispatch(event: E): void {
-    if (this.shuttingDown || this.sinks.length === 0) return;
-    const cap = this.options.maxQueueSize;
-    if (this.queue.length >= cap) {
-      this.queue.shift();
-      if (!this.backpressureActive) {
-        this.backpressureActive = true;
-        console.warn(`[rlm-telemetry] backpressure: queue saturated at ${cap}; dropping oldest events`);
-      }
-    } else if (this.backpressureActive && this.queue.length < cap - 1) {
-      this.backpressureActive = false;
-      console.warn("[rlm-telemetry] backpressure recovered: queue back under capacity");
-    }
-    this.queue.push(event);
-    this.scheduleFlush();
-  }
-
-  async shutdown(): Promise<void> {
-    this.shuttingDown = true;
-    const remaining = this.queue;
-    this.queue = [];
-    this.flushing = false;
-
-    await this.inFlight;
-
-    for (const event of remaining) await this.broadcast(event);
-    const sinks = [...this.sinks];
-    await Promise.allSettled(sinks.map((sink) => sink.flush()));
-    await Promise.allSettled(sinks.map((sink) => sink.shutdown()));
-  }
-
-  reset(): void {
-    this.sinks.length = 0;
-    this.queue = [];
-    this.flushing = false;
-    this.inFlight = Promise.resolve();
-    this.shuttingDown = false;
-    this.backpressureActive = false;
-    this.failed.clear();
-  }
-
-  private scheduleFlush(): void {
-    if (this.flushing) return;
-    this.flushing = true;
-    this.drain();
-  }
-
-  private drain(): void {
-    if (this.queue.length === 0) {
-      this.flushing = false;
-      return;
-    }
-    const batch = this.queue;
-    this.queue = [];
-
-    this.inFlight = this.inFlight.then(async () => {
-      for (const event of batch) await this.broadcast(event);
-      if (this.queue.length > 0) {
-        const handle = setImmediate(() => this.drain());
-        handle.unref?.();
-      } else {
-        this.flushing = false;
-      }
-    });
-  }
-
-  private async broadcast(event: E): Promise<void> {
-    const sinks = [...this.sinks];
-    const results = await Promise.allSettled(sinks.map((sink) => sink.handle(event)));
-    results.forEach((result, idx) => {
-      const name = sinks[idx]?.name;
-      if (!name) return;
-      if (result.status === "rejected") {
-        if (!this.failed.has(name)) {
-          this.failed.add(name);
-          const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
-          console.warn(`[rlm-telemetry] sink ${name} rejected event: ${reason}`);
-        }
-      } else if (this.failed.has(name)) {
-        this.failed.delete(name);
-        console.warn(`[rlm-telemetry] sink ${name} recovered`);
-      }
-    });
-  }
-}

package/src/telemetry/index.ts

@@ -1,14 +0,0 @@
-import type { TelemetryConfig } from "../core/types.ts";
-import { resolveMlflowConfig } from "./mlflow-config.ts";
-import type { TelemetrySink } from "./sink.ts";
-
-export type { TelemetrySink };
-
-export async function createTelemetrySink(config: TelemetryConfig | undefined): Promise<TelemetrySink | undefined> {
-  if (!config) return undefined;
-  const resolved = resolveMlflowConfig({ trackingUri: config.trackingUri, experimentId: config.experimentId });
-  const enabled = config.enabled ?? Boolean(resolved.trackingUri);
-  if (!enabled || !resolved.trackingUri) return undefined;
-  const { MlflowSink } = await import("./mlflow-sink.ts");
-  return new MlflowSink(resolved, config.maxQueueSize);
-}

package/src/telemetry/mlflow-config.ts

@@ -1,15 +0,0 @@
-export interface MlflowConfig {
-  readonly trackingUri?: string;
-  readonly experimentId?: string;
-  readonly trackingToken?: string;
-}
-
-const readEnv = (key: string): string | undefined => process.env[key]?.trim() || undefined;
-
-export function resolveMlflowConfig(config: Pick<MlflowConfig, "trackingUri" | "experimentId">): MlflowConfig {
-  return {
-    trackingUri: readEnv("MLFLOW_TRACKING_URI") || config.trackingUri,
-    experimentId: readEnv("MLFLOW_EXPERIMENT_ID") || config.experimentId,
-    trackingToken: readEnv("MLFLOW_TRACKING_TOKEN"),
-  };
-}