@schlenkr/ragents 0.1.4 → 0.1.6

package/bundles/ragents.watch/server/chunks/chunk-FHAM6OML.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../plugins/ragents.watch/server/contract.ts"],
+  "sourcesContent": ["import { serviceToken, type ServiceToken } from \"@ragents/engine\";\nimport type { WatchServiceApi } from \"../contract.js\";\n\nexport const watchServiceToken: ServiceToken<WatchServiceApi> = serviceToken(\"ragents.watch.service\");\n"],
+  "mappings": ";;;;AAAA,SAAS,oBAAuC;AAGzC,IAAM,oBAAmD,aAAa,uBAAuB;",
+  "names": []
+}

package/bundles/ragents.watch/server/chunks/chunk-RPBX3J4P.js

@@ -0,0 +1,10 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+
+// contract.ts
+var WATCH_PLUGIN_ID = "ragents.watch";
+
+export {
+  WATCH_PLUGIN_ID
+};
+//# sourceMappingURL=chunk-RPBX3J4P.js.map

package/bundles/ragents.watch/server/chunks/chunk-RPBX3J4P.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../plugins/ragents.watch/contract.ts"],
+  "sourcesContent": ["export const WATCH_PLUGIN_ID = \"ragents.watch\";\n\nexport type WatchDefinition = {\n  id: string;\n  sourceActorId: string;\n  sourceHandle: string;\n  targetActorId: string;\n  targetHandle: string;\n  condition: string;\n  observe?: string;\n  instruction?: string;\n  stallAfterSeconds?: number;\n  createdBy: string;\n};\n\nexport type WatchVerdict = {\n  at: string;\n  wake: boolean;\n  reason: string;\n  changes: string[];\n};\n\nexport type WatchSummary = {\n  id: string;\n  source: string;\n  target: string;\n  condition: string;\n  observe?: string;\n  stallAfterSeconds?: number;\n  wakes: number;\n  lastEvaluatedAt?: string;\n  lastVerdict?: WatchVerdict;\n};\n\nexport type WatchRequest = {\n  source: string;\n  condition: string;\n  target?: string;\n  observe?: string;\n  instruction?: string;\n  stallAfterSeconds?: number;\n};\n\nexport interface WatchServiceApi {\n  create(runId: string, callerActorId: string, request: WatchRequest): Promise<WatchSummary>;\n  list(runId: string): WatchSummary[];\n  remove(runId: string, watchId: string, reason: string): void;\n}\n"],
+  "mappings": ";;;;AAAO,IAAM,kBAAkB;",
+  "names": []
+}

package/bundles/ragents.watch/server/exports/contract.js

@@ -0,0 +1,9 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+import {
+  WATCH_PLUGIN_ID
+} from "../chunks/chunk-RPBX3J4P.js";
+export {
+  WATCH_PLUGIN_ID
+};
+//# sourceMappingURL=contract.js.map

package/bundles/ragents.watch/server/exports/contract.js.map

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

package/bundles/ragents.watch/server/exports/server/contract.js

@@ -0,0 +1,9 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+import {
+  watchServiceToken
+} from "../../chunks/chunk-FHAM6OML.js";
+export {
+  watchServiceToken
+};
+//# sourceMappingURL=contract.js.map

package/bundles/ragents.watch/server/exports/server/contract.js.map

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

package/bundles/ragents.watch/server/index.js

@@ -0,0 +1,482 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+import {
+  WATCH_PLUGIN_ID
+} from "./chunks/chunk-RPBX3J4P.js";
+import {
+  watchServiceToken
+} from "./chunks/chunk-FHAM6OML.js";
+
+// server/index.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { runtimeProviderToken } from "@ragents/host/ragents/host-services.js";
+
+// server/condition.ts
+import { createContext, runInContext } from "node:vm";
+import { compileVirtualTypeScriptAsync } from "@ragents/engine";
+var conditionFile = "watch-condition.ts";
+var RUN_TIMEOUT_MS = 200;
+var REASON_CHARS = 300;
+var watchStateDeclarations = `interface WatchTurn { readonly status: string; readonly reason?: string }
+interface WatchSource {
+  readonly lifecycle: "idle" | "running" | "stopped";
+  readonly stopReason?: string;
+  readonly completedTurns: number;
+  readonly lastTurn?: WatchTurn;
+  readonly pendingInputs: number;
+  readonly pendingActions: number;
+  readonly lastOutput?: string;
+}
+interface WatchState {
+  readonly source: WatchSource;
+  readonly observed?: Record<string, unknown>;
+  readonly stalledForSeconds?: number;
+}
+`;
+var WatchConditionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WatchConditionError";
+  }
+};
+var compileWatchCondition = async (condition, signal) => {
+  if (!condition.trim()) throw new WatchConditionError("Die Weckbedingung darf nicht leer sein.");
+  const compiled = await compileVirtualTypeScriptAsync({
+    sources: [{ fileName: conditionFile, text: `${watchStateDeclarations}
+const wake = (now: WatchState, before: WatchState): string | undefined => {
+${condition}
+};
+` }],
+    emit: "node"
+  }, { signal });
+  if (!compiled.valid) {
+    throw new WatchConditionError(`Die Weckbedingung ist kein g\xFCltiges TypeScript:
+${compiled.diagnostics.map((diagnostic) => `${diagnostic.start ? `${Math.max(1, diagnostic.start.line - watchStateDeclarations.split("\n").length)}:${diagnostic.start.column} ` : ""}TS${diagnostic.code}: ${diagnostic.message}`).join("\n")}`);
+  }
+  const emitted = compiled.emittedFiles.find((file) => file.fileName.endsWith(".js"));
+  if (!emitted) throw new WatchConditionError("Die Weckbedingung hat keinen JavaScript-Code erzeugt.");
+  const sandbox = createContext(/* @__PURE__ */ Object.create(null));
+  runInContext(`${emitted.text}
+globalThis.wake = wake;`, sandbox, { timeout: RUN_TIMEOUT_MS });
+  return (now, before) => {
+    sandbox.now = now;
+    sandbox.before = before;
+    const result = runInContext("wake(now, before)", sandbox, { timeout: RUN_TIMEOUT_MS });
+    if (result === void 0 || result === null || result === false) return void 0;
+    if (typeof result !== "string" || !result.trim()) throw new WatchConditionError(`Die Weckbedingung muss einen Grund als Text oder nichts liefern, nicht ${JSON.stringify(result)}.`);
+    return result.trim().slice(0, REASON_CHARS);
+  };
+};
+
+// server/functions.ts
+import { Type } from "typebox";
+import { defineRunFunction, defineToolAvailability } from "@ragents/engine";
+import { toolDescriptorFrom } from "@ragents/host/plugin-support/agent-tool.js";
+var available = defineToolAvailability({ availability: "always", availabilityDetail: "In jedem Run verf\xFCgbar." }, () => true);
+var verdictSchema = Type.Object({
+  at: Type.String({ description: "Zeitpunkt der Bewertung" }),
+  wake: Type.Boolean({ description: "Ob der W\xE4chter geweckt hat" }),
+  reason: Type.String({ description: "Grund, den die Bedingung geliefert hat, oder 'Bedingung nicht erf\xFCllt'" }),
+  changes: Type.Array(Type.String(), { description: "\xC4nderungen seit der letzten Weckung, die der Bewertung vorlagen" })
+}, { additionalProperties: false });
+var summarySchema = Type.Object({
+  id: Type.String({ description: "Kennung des W\xE4chters f\xFCr watch_remove" }),
+  source: Type.String({ description: "Beobachteter Actor als @handle" }),
+  target: Type.String({ description: "Geweckter Actor als @handle" }),
+  condition: Type.String({ description: "Weckbedingung als TypeScript-Funktionsrumpf" }),
+  observe: Type.Optional(Type.String({ description: "Benannte Operation, deren Ergebnis zum beobachteten Stand geh\xF6rt" })),
+  stallAfterSeconds: Type.Optional(Type.Integer({ description: "Sekunden ohne Ereignis des beobachteten Actors, ab denen der Stand einen Stillstand nennt" })),
+  wakes: Type.Integer({ description: "Anzahl der bisherigen Weckungen" }),
+  lastEvaluatedAt: Type.Optional(Type.String({ description: "Zeitpunkt der letzten Bewertung" })),
+  lastVerdict: Type.Optional(verdictSchema)
+}, { additionalProperties: false });
+var createSchema = Type.Object({
+  source: Type.String({ minLength: 1, description: "Beobachteter Actor als @handle oder Kennung" }),
+  condition: Type.String({ minLength: 1, maxLength: 4e3, description: 'Weckbedingung als TypeScript-Funktionsrumpf von (now: WatchState, before: WatchState) => string | undefined; liefert den Weckgrund als Text oder undefined. WatchState: source { lifecycle idle|running|stopped, completedTurns, lastTurn { status, reason? }, pendingInputs, pendingActions, lastOutput? }, observed (Ergebnis der observe-Operation als Record<string, unknown>), stalledForSeconds (nur bei Stillstand). before ist der Stand bei der letzten Weckung. Beispiel: return now.source.completedTurns > before.source.completedTurns && now.observed?.phase !== "ready" ? "Turn beendet, Auftrag nicht fertig" : undefined;' }),
+  target: Type.Optional(Type.String({ minLength: 1, description: "Zu weckender Actor als @handle oder Kennung; ohne Angabe der Aufrufer" })),
+  observe: Type.Optional(Type.String({ minLength: 1, description: "Benannte Operation ohne Eingabe, deren Ergebnis den beobachteten Stand erg\xE4nzt und per Differenz verglichen wird" })),
+  instruction: Type.Optional(Type.String({ minLength: 1, maxLength: 2e3, description: "Text, der jeder Weckung angeh\xE4ngt wird, etwa wie der Geweckte reagieren soll" })),
+  stallAfterSeconds: Type.Optional(Type.Integer({ minimum: 1, description: "Sekunden ohne Ereignis des beobachteten Actors, ab denen der Stand stalledForSeconds nennt" }))
+}, { additionalProperties: false });
+var watchFunctions = (service) => {
+  const functions = [
+    defineRunFunction({
+      name: "watch_create",
+      label: "W\xE4chter anlegen",
+      description: "Beobachtet einen Actor dieses Runs und weckt einen anderen mit einer Hintergrundnachricht, sobald die als TypeScript-Funktionsrumpf formulierte Bedingung im ge\xE4nderten Stand einen Grund liefert. Kein Modell: Die Bedingung wird beim Anlegen typgepr\xFCft und danach deterministisch bei jeder \xC4nderung des beobachteten Stands ausgef\xFChrt, sobald der beobachtete Actor zur Ruhe gekommen ist; stalledForSeconds erscheint nach stallAfterSeconds ohne Aktivit\xE4t und danach je weitere Periode erneut. Ein gleicher W\xE4chter wird nicht doppelt angelegt.",
+      schema: createSchema,
+      resultSchema: summarySchema,
+      available,
+      run: (scope, _toolCallId, input) => service.create(scope.caller.runId, scope.caller.actorId, input)
+    }),
+    defineRunFunction({
+      name: "watch_list",
+      label: "W\xE4chter auflisten",
+      description: "Listet die W\xE4chter dieses Runs mit Bedingung, Anzahl der Weckungen und letztem Urteil.",
+      schema: Type.Object({}, { additionalProperties: false }),
+      resultSchema: Type.Array(summarySchema),
+      available,
+      run: (scope) => service.list(scope.caller.runId)
+    }),
+    defineRunFunction({
+      name: "watch_remove",
+      label: "W\xE4chter entfernen",
+      description: "Entfernt einen W\xE4chter dieses Runs; danach weckt er nicht mehr.",
+      schema: Type.Object({
+        id: Type.String({ minLength: 1, description: "Kennung aus watch_create oder watch_list" }),
+        reason: Type.String({ minLength: 1, description: "Grund der Entfernung" })
+      }, { additionalProperties: false }),
+      resultSchema: Type.Object({ removed: Type.Literal(true) }, { additionalProperties: false }),
+      available,
+      run: (scope, _toolCallId, input) => {
+        service.remove(scope.caller.runId, input.id, input.reason);
+        return { removed: true };
+      }
+    })
+  ];
+  return { name: "ragents.watch", descriptors: functions.map((fn) => toolDescriptorFrom(fn, available)), tools: () => functions };
+};
+
+// server/service.ts
+import { randomUUID } from "node:crypto";
+import { DomainError } from "@ragents/engine";
+
+// server/observation.ts
+import { actorByReference } from "@ragents/engine";
+var OUTPUT_CHARS = 600;
+var watchableActorOf = (view, reference) => {
+  const actor = actorByReference(view.actors, reference);
+  return actor?.kind === "human" ? void 0 : actor;
+};
+var observeActor = (view, actorId) => {
+  const actor = view.actors.find((candidate) => candidate.kind !== "human" && candidate.id === actorId);
+  if (!actor) return void 0;
+  const turns = view.turns.filter((turn) => turn.actorId === actorId);
+  const last = turns.at(-1);
+  const output = turns.findLast((turn) => turn.status !== "running" && turn.outputs.length > 0)?.outputs.at(-1)?.text;
+  return {
+    lifecycle: actor.lifecycle.kind,
+    ...actor.lifecycle.kind === "stopped" ? { stopReason: actor.lifecycle.reason } : {},
+    completedTurns: turns.filter((turn) => turn.status !== "running").length,
+    ...last ? { lastTurn: { status: last.status, ...last.reason ? { reason: last.reason } : {} } } : {},
+    pendingInputs: view.inputs.filter((input) => input.actorId === actorId && input.lifecycle.kind === "pending").length,
+    pendingActions: view.actions.filter((action) => action.askedBy === actorId && action.status === "pending").length,
+    ...output ? { lastOutput: output.length > OUTPUT_CHARS ? `...${output.slice(-OUTPUT_CHARS)}` : output } : {}
+  };
+};
+var lastActivityOf = (events, actor) => {
+  const event = events.findLast((candidate) => candidate.actorId === actor.id || candidate.type === "actor.input.enqueued" && candidate.payload.actorId === actor.id || (candidate.type === "turn.finished" || candidate.type === "turn.interrupted") && candidate.actorId === actor.id);
+  return event?.occurredAt ?? actor.createdAt;
+};
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var flattenJson = (value, prefix = "", into = /* @__PURE__ */ new Map()) => {
+  if (Array.isArray(value)) {
+    if (value.length === 0 && prefix) into.set(prefix, "[]");
+    value.forEach((entry, index) => flattenJson(entry, prefix ? `${prefix}.${index}` : String(index), into));
+  } else if (isObject(value)) {
+    const keys = Object.keys(value);
+    if (keys.length === 0 && prefix) into.set(prefix, "{}");
+    for (const key of keys) flattenJson(value[key], prefix ? `${prefix}.${key}` : key, into);
+  } else into.set(prefix || "$", JSON.stringify(value));
+  return into;
+};
+var changesBetween = (before, after) => {
+  const previous = before === void 0 ? /* @__PURE__ */ new Map() : flattenJson(before);
+  const current = flattenJson(after);
+  const lines = [];
+  for (const [path, value] of current) {
+    const old = previous.get(path);
+    if (old === void 0) lines.push(`${path}: ${value}${before === void 0 ? "" : " (neu)"}`);
+    else if (old !== value) lines.push(`${path}: ${old} -> ${value}`);
+  }
+  for (const path of previous.keys()) if (!current.has(path)) lines.push(`${path}: entfernt`);
+  return lines;
+};
+
+// server/service.ts
+var CONDITION_CHARS = 4e3;
+var INSTRUCTION_CHARS = 2e3;
+var HISTORY_LENGTH = 10;
+var summaryOf = (watch) => ({
+  id: watch.definition.id,
+  source: `@${watch.definition.sourceHandle}`,
+  target: `@${watch.definition.targetHandle}`,
+  condition: watch.definition.condition,
+  ...watch.definition.observe ? { observe: watch.definition.observe } : {},
+  ...watch.definition.stallAfterSeconds ? { stallAfterSeconds: watch.definition.stallAfterSeconds } : {},
+  wakes: watch.wakes,
+  ...watch.lastEvaluatedAt ? { lastEvaluatedAt: watch.lastEvaluatedAt } : {},
+  ...watch.history.length ? { lastVerdict: watch.history[watch.history.length - 1] } : {}
+});
+var invalid = (message) => new DomainError("watch-invalid", message, 400);
+var cleanText = (value, field, limit) => {
+  if (value === void 0) return void 0;
+  const text = value.trim();
+  if (!text) throw invalid(`${field} darf nicht leer sein.`);
+  if (text.length > limit) throw invalid(`${field} darf h\xF6chstens ${limit} Zeichen enthalten.`);
+  return text;
+};
+var wakeMessage = (definition, reason, changes) => [
+  `Der W\xE4chter weckt Dich: ${reason}`,
+  `\xC4nderungen bei @${definition.sourceHandle} seit der letzten Weckung:
+${changes.length ? changes.map((line) => `- ${line}`).join("\n") : "- keine"}`,
+  ...definition.instruction ? [definition.instruction] : []
+].join("\n");
+var WatchService = class {
+  #options;
+  #runs = /* @__PURE__ */ new Map();
+  #closed = false;
+  constructor(options) {
+    this.#options = options;
+  }
+  #now() {
+    return this.#options.now ? this.#options.now() : Date.parse(this.#options.runtime().now());
+  }
+  async create(runId, callerActorId, request) {
+    const runtime = this.#options.runtime();
+    const view = runtime.view(runId);
+    const source = watchableActorOf(view, request.source);
+    if (!source) throw invalid(`Der beobachtete Actor ${request.source} existiert in diesem Run nicht.`);
+    const target = request.target ? watchableActorOf(view, request.target) : watchableActorOf(view, callerActorId);
+    if (!target) throw invalid(`Der zu weckende Actor ${request.target ?? callerActorId} existiert in diesem Run nicht oder ist kein Agent.`);
+    const condition = cleanText(request.condition, "condition", CONDITION_CHARS);
+    const instruction = cleanText(request.instruction, "instruction", INSTRUCTION_CHARS);
+    if (request.observe !== void 0 && !this.#options.operationExists(request.observe)) throw invalid(`Die Operation ${request.observe} ist nicht registriert.`);
+    if (request.stallAfterSeconds !== void 0 && (!Number.isInteger(request.stallAfterSeconds) || request.stallAfterSeconds < 1)) throw invalid("stallAfterSeconds muss eine positive ganze Zahl sein.");
+    const run = this.#ensure(runId);
+    const existing = [...run.watches.values()].find((watch2) => watch2.definition.sourceActorId === source.id && watch2.definition.targetActorId === target.id && watch2.definition.condition === condition);
+    if (existing) return summaryOf(existing);
+    const predicate = await this.#options.compile(condition, run.abort.signal);
+    if (this.#runs.get(runId) !== run) throw invalid("Der Run wurde w\xE4hrend des Anlegens beendet.");
+    const definition = {
+      id: `watch_${randomUUID()}`,
+      sourceActorId: source.id,
+      sourceHandle: source.handle,
+      targetActorId: target.id,
+      targetHandle: target.handle,
+      condition,
+      ...request.observe !== void 0 ? { observe: request.observe } : {},
+      ...instruction !== void 0 ? { instruction } : {},
+      ...request.stallAfterSeconds !== void 0 ? { stallAfterSeconds: request.stallAfterSeconds } : {},
+      createdBy: callerActorId
+    };
+    const watch = { definition, predicate, wakes: 0, history: [] };
+    run.watches.set(definition.id, watch);
+    this.#persist(run);
+    this.#updateStallTimer(run);
+    this.#schedule(run, true);
+    return summaryOf(watch);
+  }
+  list(runId) {
+    return [...this.#runs.get(runId)?.watches.values() ?? []].map(summaryOf);
+  }
+  remove(runId, watchId, reason) {
+    const run = this.#runs.get(runId);
+    const watch = run?.watches.get(watchId);
+    if (!run || !watch) throw new DomainError("watch-unknown", `Der W\xE4chter ${watchId} existiert in diesem Run nicht.`, 404);
+    if (!reason.trim()) throw invalid("reason darf nicht leer sein.");
+    run.watches.delete(watchId);
+    this.#persist(run);
+    this.#updateStallTimer(run);
+  }
+  async prepare(runId) {
+    if (this.#closed || this.#runs.has(runId)) return;
+    const runtime = this.#options.runtime();
+    if (runtime.events(runId).length === 0) return;
+    const stored = this.#stored(runtime.view(runId));
+    if (stored.length === 0) return;
+    const run = this.#ensure(runId);
+    for (const entry of stored) {
+      const { baseline, wakes, history, ...definition } = entry;
+      const predicate = await this.#options.compile(definition.condition, run.abort.signal);
+      if (this.#runs.get(runId) !== run) return;
+      run.watches.set(definition.id, { definition, predicate, ...baseline !== void 0 ? { baseline } : {}, wakes, history: history ?? [] });
+    }
+    this.#updateStallTimer(run);
+    this.#schedule(run, true);
+  }
+  stop(runId) {
+    const run = this.#runs.get(runId);
+    if (!run) return;
+    this.#runs.delete(runId);
+    run.unsubscribe();
+    run.abort.abort();
+    if (run.debounce) clearTimeout(run.debounce);
+    if (run.stallTimer) clearInterval(run.stallTimer);
+  }
+  shutdown() {
+    for (const runId of [...this.#runs.keys()]) this.stop(runId);
+    this.#closed = true;
+  }
+  #stored(view) {
+    const state = view.pluginStates.find((entry) => entry.pluginId === WATCH_PLUGIN_ID && entry.scope.kind === "run")?.state;
+    return state?.watches ?? [];
+  }
+  #ensure(runId) {
+    if (this.#closed) throw new Error("Der W\xE4chterdienst ist beendet.");
+    const existing = this.#runs.get(runId);
+    if (existing) return existing;
+    const runtime = this.#options.runtime();
+    const run = {
+      runId,
+      unsubscribe: runtime.subscribe((events) => {
+        if (events.some((event) => event.runId === runId)) this.#schedule(run);
+      }),
+      abort: new AbortController(),
+      watches: /* @__PURE__ */ new Map(),
+      dirty: false
+    };
+    this.#runs.set(runId, run);
+    return run;
+  }
+  #persist(run) {
+    const runtime = this.#options.runtime();
+    const view = runtime.view(run.runId);
+    const state = { version: 1, watches: [...run.watches.values()].map((watch) => ({ ...watch.definition, ...watch.baseline !== void 0 ? { baseline: watch.baseline } : {}, wakes: watch.wakes, history: watch.history })) };
+    runtime.replacePluginState({ actorId: view.ownerId, commandId: `ragents.watch:state:${randomUUID()}` }, run.runId, { pluginId: WATCH_PLUGIN_ID, scope: { kind: "run" }, state });
+  }
+  #updateStallTimer(run) {
+    const needed = [...run.watches.values()].some((watch) => watch.definition.stallAfterSeconds !== void 0);
+    if (!needed && run.stallTimer) {
+      clearInterval(run.stallTimer);
+      run.stallTimer = void 0;
+    }
+    if (needed && !run.stallTimer) {
+      run.stallTimer = setInterval(() => this.#schedule(run), this.#options.stallCheckMs ?? 3e4);
+      run.stallTimer.unref();
+    }
+  }
+  #schedule(run, immediate = false) {
+    if (this.#runs.get(run.runId) !== run) return;
+    if (run.evaluating) {
+      run.dirty = true;
+      return;
+    }
+    if (immediate) {
+      if (run.debounce) {
+        clearTimeout(run.debounce);
+        run.debounce = void 0;
+      }
+      this.#start(run);
+      return;
+    }
+    if (run.debounce) return;
+    run.debounce = setTimeout(() => {
+      run.debounce = void 0;
+      this.#start(run);
+    }, this.#options.debounceMs ?? 1e3);
+    run.debounce.unref();
+  }
+  #start(run) {
+    run.evaluating = this.#evaluateAll(run).finally(() => {
+      run.evaluating = void 0;
+      if (run.dirty) {
+        run.dirty = false;
+        this.#schedule(run);
+      }
+    });
+  }
+  async #evaluateAll(run) {
+    for (const watch of [...run.watches.values()]) {
+      if (this.#runs.get(run.runId) !== run || !run.watches.has(watch.definition.id)) return;
+      try {
+        await this.#evaluate(run, watch);
+      } catch (error) {
+        if (run.abort.signal.aborted) return;
+        (this.#options.log ?? ((message, cause) => console.error(message, cause)))(`W\xE4chter ${watch.definition.id} in Run ${run.runId} konnte nicht bewerten:`, error);
+      }
+    }
+  }
+  async #evaluate(run, watch) {
+    const runtime = this.#options.runtime();
+    const view = runtime.view(run.runId);
+    const source = view.actors.find((actor) => actor.kind !== "human" && actor.id === watch.definition.sourceActorId);
+    const target = view.actors.find((actor) => actor.kind !== "human" && actor.id === watch.definition.targetActorId);
+    if (!source || !target || target.lifecycle.kind === "stopped") return;
+    const observation = await this.#observe(run, watch, view, source, runtime.events(run.runId));
+    if (this.#runs.get(run.runId) !== run || !run.watches.has(watch.definition.id)) return;
+    const key = JSON.stringify(observation);
+    if (watch.baseline === void 0) {
+      watch.baseline = observation;
+      watch.lastEvaluated = key;
+      this.#persist(run);
+      return;
+    }
+    if (key === watch.lastEvaluated) return;
+    const current = runtime.view(run.runId);
+    const busy = current.actors.find((actor) => actor.kind !== "human" && actor.id === target.id)?.lifecycle.kind !== "idle" || current.inputs.some((input) => input.actorId === target.id && input.lifecycle.kind === "pending") || current.actions.some((action) => action.askedBy === target.id && action.status === "pending");
+    if (busy) return;
+    const unsettled = source.lifecycle.kind === "running" || current.inputs.some((input) => input.actorId === source.id && input.lifecycle.kind === "pending");
+    if (unsettled && !(typeof observation === "object" && observation !== null && "stalledForSeconds" in observation)) return;
+    const changes = changesBetween(watch.baseline, observation);
+    const judged = JSON.stringify(changes);
+    if (changes.length === 0 || judged === watch.lastJudgedChanges) {
+      watch.lastEvaluated = key;
+      return;
+    }
+    const reason = watch.predicate(observation, watch.baseline);
+    const at = new Date(this.#now()).toISOString();
+    watch.lastEvaluated = key;
+    watch.lastEvaluatedAt = at;
+    watch.lastJudgedChanges = judged;
+    watch.history = [...watch.history, { at, wake: reason !== void 0, reason: reason ?? "Bedingung nicht erf\xFCllt", changes }].slice(-HISTORY_LENGTH);
+    if (reason === void 0) {
+      if (changes.some((line) => !line.startsWith("stalledForSeconds:"))) this.#persist(run);
+      return;
+    }
+    runtime.enqueueInput({ actorId: current.ownerId, commandId: `ragents.watch:wake:${watch.definition.id}:${randomUUID()}` }, run.runId, {
+      actorId: target.id,
+      presentation: "background",
+      content: wakeMessage(watch.definition, reason, changes)
+    });
+    watch.baseline = observation;
+    watch.wakes += 1;
+    this.#persist(run);
+  }
+  async #observe(run, watch, view, source, events) {
+    const observed = watch.definition.observe ? await this.#options.observe(run.runId, watch.definition.observe, run.abort.signal) : void 0;
+    const stall = watch.definition.stallAfterSeconds;
+    const age = stall ? this.#now() - Date.parse(lastActivityOf(events, source)) : 0;
+    return {
+      source: observeActor(view, source.id),
+      ...observed !== void 0 ? { observed } : {},
+      ...stall && age >= stall * 1e3 ? { stalledForSeconds: Math.floor(age / (stall * 1e3)) * stall } : {}
+    };
+  }
+};
+
+// server/index.ts
+var watchPlugin = {
+  manifest: { id: WATCH_PLUGIN_ID },
+  register: (host) => {
+    const runtime = host.service(runtimeProviderToken);
+    const service = new WatchService({
+      runtime,
+      compile: (condition, signal) => compileWatchCondition(condition, signal),
+      operationExists: (id) => host.operation(id) !== void 0,
+      observe: (runId, id, signal) => host.invokeOperation(id, {
+        runId,
+        invocationId: `ragents.watch:${randomUUID2()}`,
+        signal,
+        principal: { kind: "operator", actorId: runtime().view(runId).ownerId }
+      }, {})
+    });
+    host.provide(watchServiceToken, service);
+    host.functions(watchFunctions(service));
+    host.lifecycle({
+      id: "ragents.watch.lifecycle",
+      prepareSession: ({ runId }) => service.prepare(runId),
+      stopSession: ({ runId }) => service.stop(runId),
+      deleteSession: ({ runId }) => service.stop(runId),
+      shutdown: () => service.shutdown()
+    });
+  }
+};
+var plugin = {
+  requires: ["ragents.orchestration"],
+  create: () => watchPlugin
+};
+export {
+  plugin
+};
+//# sourceMappingURL=index.js.map