@cuylabs/agent-core 0.9.0 → 0.11.0

package/dist/chunk-2TTOLHBT.js

@@ -0,0 +1,198 @@
+// src/events/local.ts
+function createEventBus(options = {}) {
+  const channels = /* @__PURE__ */ new Map();
+  const maxHistoryMessages = Math.max(1, options.maxHistoryMessages ?? 1024);
+  const maxBufferedMessages = Math.max(1, options.maxBufferedMessages ?? 512);
+  const channelRetentionMs = Math.max(
+    1e3,
+    options.channelRetentionMs ?? 10 * 60 * 1e3
+  );
+  function getOrCreateChannel(channel) {
+    let state = channels.get(channel);
+    if (!state) {
+      state = {
+        seq: 0,
+        subscribers: /* @__PURE__ */ new Set(),
+        closed: false,
+        history: []
+      };
+      channels.set(channel, state);
+    } else if (state.cleanupTimer) {
+      clearTimeout(state.cleanupTimer);
+      state.cleanupTimer = void 0;
+    }
+    return state;
+  }
+  function scheduleCleanup(channel, state) {
+    if (state.cleanupTimer) {
+      clearTimeout(state.cleanupTimer);
+    }
+    state.cleanupTimer = setTimeout(() => {
+      const current = channels.get(channel);
+      if (current !== state) {
+        return;
+      }
+      if (current.subscribers.size === 0) {
+        channels.delete(channel);
+      }
+    }, channelRetentionMs);
+  }
+  function appendToHistory(state, message) {
+    state.history.push(message);
+    if (state.history.length > maxHistoryMessages) {
+      state.history.splice(0, state.history.length - maxHistoryMessages);
+    }
+  }
+  return {
+    get activeChannels() {
+      let count = 0;
+      for (const state of channels.values()) {
+        if (state.subscribers.size > 0) count++;
+      }
+      return count;
+    },
+    publish(channel, type, data) {
+      const state = getOrCreateChannel(channel);
+      if (state.closed) {
+        state.closed = false;
+        state.seq = 0;
+        state.history = [];
+      }
+      state.seq++;
+      const message = {
+        channel,
+        type,
+        data,
+        seq: state.seq
+      };
+      appendToHistory(state, message);
+      for (const sub of state.subscribers) {
+        sub.push(message);
+      }
+      if (state.subscribers.size === 0) {
+        scheduleCleanup(channel, state);
+      }
+    },
+    subscribe(channel, subscribeOptions = {}) {
+      const state = getOrCreateChannel(channel);
+      const afterSeq = typeof subscribeOptions.afterSeq === "number" && Number.isFinite(subscribeOptions.afterSeq) && subscribeOptions.afterSeq >= 0 ? subscribeOptions.afterSeq : void 0;
+      const initialBuffer = state.history.filter(
+        (message) => afterSeq === void 0 ? true : message.seq > afterSeq
+      );
+      const closedAtSubscribe = state.closed;
+      const buffer = [...initialBuffer];
+      let waiting = null;
+      let done = false;
+      let closedAfterBuffer = closedAtSubscribe;
+      let unsubscribe = () => {
+      };
+      const subscriber = {
+        push(message) {
+          if (done) return;
+          if (waiting) {
+            const resolve = waiting;
+            waiting = null;
+            resolve({ value: message, done: false });
+          } else {
+            if (buffer.length >= maxBufferedMessages) {
+              unsubscribe();
+              return;
+            }
+            buffer.push(message);
+          }
+        },
+        complete() {
+          if (done) return;
+          closedAfterBuffer = true;
+          if (waiting) {
+            const resolve = waiting;
+            waiting = null;
+            if (buffer.length > 0) {
+              resolve({ value: buffer.shift(), done: false });
+              return;
+            }
+            done = true;
+            resolve({ value: void 0, done: true });
+          }
+        }
+      };
+      if (!closedAtSubscribe) {
+        state.subscribers.add(subscriber);
+      } else {
+        scheduleCleanup(channel, state);
+      }
+      unsubscribe = function unsubscribeImpl() {
+        if (!done) {
+          done = true;
+          state.subscribers.delete(subscriber);
+          if (state.subscribers.size === 0) {
+            scheduleCleanup(channel, state);
+          }
+          if (waiting) {
+            const resolve = waiting;
+            waiting = null;
+            resolve({ value: void 0, done: true });
+          }
+        }
+      };
+      const iterator = {
+        next() {
+          if (buffer.length > 0) {
+            return Promise.resolve({
+              value: buffer.shift(),
+              done: false
+            });
+          }
+          if (done || closedAfterBuffer) {
+            return Promise.resolve({
+              value: void 0,
+              done: true
+            });
+          }
+          return new Promise((resolve) => {
+            waiting = resolve;
+          });
+        },
+        return() {
+          unsubscribe();
+          return Promise.resolve({ value: void 0, done: true });
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+      return {
+        [Symbol.asyncIterator]() {
+          return iterator;
+        },
+        unsubscribe
+      };
+    },
+    close(channel, finalEvent) {
+      const state = getOrCreateChannel(channel);
+      state.closed = true;
+      if (finalEvent) {
+        state.seq++;
+        const message = {
+          channel,
+          type: finalEvent.type,
+          data: finalEvent.data,
+          seq: state.seq
+        };
+        appendToHistory(state, message);
+        for (const sub of state.subscribers) {
+          sub.push(message);
+        }
+      }
+      for (const sub of state.subscribers) {
+        sub.complete();
+      }
+      state.subscribers.clear();
+      scheduleCleanup(channel, state);
+    }
+  };
+}
+
+export {
+  createEventBus
+};

package/dist/chunk-5FMSGQVX.js

@@ -0,0 +1,281 @@
+import {
+  sleep
+} from "./chunk-SZ2XBPTW.js";
+
+// src/dispatch/executor.ts
+function ensureNonEmpty(input, label) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+function createTargetIndex(targets) {
+  return new Map(targets.map((target) => [target.name, target]));
+}
+function requireTarget(targets, name) {
+  const target = targets.get(name);
+  if (!target) {
+    throw new Error(
+      `Unknown dispatch target "${name}". Available: ${[...targets.keys()].join(", ")}`
+    );
+  }
+  return target;
+}
+function defaultTaskRecord(input, targetName, startedAt, dispatchId, startResult) {
+  return {
+    id: dispatchId,
+    targetType: targetName,
+    title: input.task.title,
+    brief: input.prompt,
+    status: "running",
+    createdAt: startedAt,
+    updatedAt: startedAt,
+    parentSessionId: input.parentSessionId,
+    sessionId: startResult.sessionId ?? input.runtime.member.sessionId,
+    executionId: startResult.executionId ?? input.task.runId ?? dispatchId,
+    redirectCount: 0
+  };
+}
+function defaultExternalControlRecord(task, runtime, targetName, startedAt, dispatchId) {
+  return {
+    id: dispatchId,
+    targetType: targetName,
+    title: task.title,
+    brief: task.prompt,
+    status: "running",
+    createdAt: task.createdAt || startedAt,
+    updatedAt: task.updatedAt || startedAt,
+    parentSessionId: runtime.member.sessionId,
+    sessionId: runtime.member.sessionId,
+    executionId: task.runId ?? dispatchId,
+    redirectCount: 0
+  };
+}
+function mergeInspection(record, inspection, fallbackNow) {
+  if (!inspection) {
+    return record;
+  }
+  return {
+    ...record,
+    ...inspection.status ? { status: inspection.status } : {},
+    ...inspection.sessionId ? { sessionId: inspection.sessionId } : {},
+    ...inspection.executionId ? { executionId: inspection.executionId } : {},
+    updatedAt: inspection.updatedAt ?? fallbackNow,
+    ...inspection.result ? { result: inspection.result } : {},
+    ...inspection.error ? { error: inspection.error } : {}
+  };
+}
+function toTaskResult(result) {
+  return {
+    response: result?.response ?? "",
+    usage: result?.usage,
+    toolCalls: result?.toolCalls
+  };
+}
+async function cancelBestEffort(target, record, reason) {
+  await target.cancel({ record, reason }).catch(() => {
+  });
+}
+function toInspection(record) {
+  if (!record) {
+    return void 0;
+  }
+  return {
+    status: record.status,
+    sessionId: record.sessionId,
+    executionId: record.executionId,
+    updatedAt: record.updatedAt,
+    result: record.result,
+    error: record.error
+  };
+}
+function resolveRuntimeRecordId(record) {
+  return record.executionId ?? record.id;
+}
+function createRuntimeDispatchTargets(options) {
+  return options.runtime.describeTargets().filter((target) => options.filter?.(target) ?? true).map((target) => ({
+    name: target.name,
+    description: target.description,
+    async start(input) {
+      const record = await options.runtime.start({
+        targetType: target.name,
+        brief: input.brief,
+        title: input.title,
+        parentSessionId: input.parentSessionId
+      });
+      return {
+        sessionId: record.sessionId,
+        executionId: record.id
+      };
+    },
+    async redirect(input) {
+      await options.runtime.redirect(
+        resolveRuntimeRecordId(input.record),
+        input.message
+      );
+    },
+    async cancel(input) {
+      await options.runtime.cancel(
+        resolveRuntimeRecordId(input.record),
+        input.reason
+      );
+    },
+    async check(input) {
+      const record = await options.runtime.check(
+        resolveRuntimeRecordId(input.record),
+        { waitMs: 0 }
+      );
+      return toInspection(record);
+    }
+  }));
+}
+function createDispatchTaskExecutor(options) {
+  const targets = createTargetIndex(options.targets);
+  const timeoutMs = options.timeoutMs ?? 6e5;
+  const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return async (input) => {
+    const targetName = options.resolveTargetName?.(input) ?? input.runtime.member.role;
+    const target = requireTarget(targets, ensureNonEmpty(targetName, "targetName"));
+    const startedAt = now();
+    const dispatchId = input.task.runId ?? input.task.id;
+    const startResult = await target.start({
+      id: dispatchId,
+      brief: input.prompt,
+      title: input.task.title,
+      parentSessionId: input.parentSessionId,
+      sessionId: input.runtime.member.sessionId
+    });
+    let record = options.createRecord?.({
+      taskInput: input,
+      target,
+      dispatchId,
+      startedAt,
+      startResult
+    }) ?? defaultTaskRecord(
+      input,
+      target.name,
+      startedAt,
+      dispatchId,
+      startResult
+    );
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (input.abort?.aborted) {
+        await cancelBestEffort(
+          target,
+          record,
+          String(input.abort.reason ?? "Aborted by coordinator")
+        );
+        throw new Error(String(input.abort.reason ?? "Aborted by coordinator"));
+      }
+      if (!target.check) {
+        throw new Error(
+          `Dispatch target "${target.name}" does not support status checks.`
+        );
+      }
+      const inspection = await target.check({ record });
+      record = mergeInspection(record, inspection, now());
+      if (record.status === "completed") {
+        return toTaskResult(record.result);
+      }
+      if (record.status === "failed") {
+        throw new Error(
+          record.error ?? `Dispatch "${dispatchId}" failed on target "${target.name}".`
+        );
+      }
+      if (record.status === "cancelled") {
+        throw new Error(
+          record.error ?? `Dispatch "${dispatchId}" was cancelled on target "${target.name}".`
+        );
+      }
+      await sleep(pollIntervalMs);
+    }
+    throw new Error(
+      `Dispatch "${dispatchId}" on target "${target.name}" timed out after ${timeoutMs}ms.`
+    );
+  };
+}
+function createCompositeDispatchTaskExecutor(options) {
+  return async (input) => {
+    const matched = options.routes.find((route) => route.matches(input));
+    if (matched) {
+      return matched.executor(input);
+    }
+    if (options.fallback) {
+      return options.fallback(input);
+    }
+    const result = await input.runtime.agent.run({
+      parentSessionId: input.parentSessionId,
+      message: input.prompt,
+      title: input.task.title,
+      abort: input.abort
+    });
+    return {
+      response: result.response,
+      usage: result.usage,
+      toolCalls: result.toolCalls
+    };
+  };
+}
+function createRuntimeDispatchExecutor(options) {
+  return createDispatchTaskExecutor({
+    targets: createRuntimeDispatchTargets({
+      runtime: options.runtime,
+      filter: options.filter
+    }),
+    timeoutMs: options.timeoutMs,
+    pollIntervalMs: options.pollIntervalMs,
+    now: options.now,
+    resolveTargetName: options.resolveTargetName,
+    createRecord: options.createRecord
+  });
+}
+function createDispatchExternalTaskControl(options) {
+  const targets = createTargetIndex(options.targets);
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  function resolveRecord(task, runtime) {
+    const targetName = options.resolveTargetName?.({ task, runtime }) ?? runtime.role.name;
+    const target = requireTarget(targets, ensureNonEmpty(targetName, "targetName"));
+    const dispatchId = task.runId ?? task.id;
+    const startedAt = now();
+    const record = options.createRecord?.({
+      task,
+      runtime,
+      target,
+      dispatchId,
+      startedAt
+    }) ?? defaultExternalControlRecord(
+      task,
+      runtime,
+      target.name,
+      startedAt,
+      dispatchId
+    );
+    return { target, record };
+  }
+  return {
+    async abortTask({ task, runtime, reason }) {
+      const { target, record } = resolveRecord(task, runtime);
+      await target.cancel({ record, reason });
+    },
+    async guideTask({ task, runtime, message }) {
+      const { target, record } = resolveRecord(task, runtime);
+      await target.redirect({
+        record,
+        message: ensureNonEmpty(message, "message")
+      });
+    }
+  };
+}
+
+export {
+  ensureNonEmpty,
+  mergeInspection,
+  createRuntimeDispatchTargets,
+  createDispatchTaskExecutor,
+  createCompositeDispatchTaskExecutor,
+  createRuntimeDispatchExecutor,
+  createDispatchExternalTaskControl
+};