@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-X4VN4GIJ.js

@@ -0,0 +1,185 @@
+// src/tool/host/local.ts
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import process from "process";
+function getShell() {
+  if (process.platform === "win32") {
+    return { shell: "cmd.exe", args: ["/c"] };
+  }
+  const userShell = process.env.SHELL ?? "/bin/bash";
+  return { shell: userShell, args: ["-c"] };
+}
+async function killProcessTree(pid) {
+  try {
+    if (process.platform !== "win32") {
+      process.kill(-pid, "SIGKILL");
+    } else {
+      const { exec: execCb } = await import("child_process");
+      execCb(`taskkill /pid ${pid} /t /f`, () => {
+      });
+    }
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+function localHost(defaultCwd) {
+  const cwd = defaultCwd ?? process.cwd();
+  return {
+    name: "local",
+    // --------------------------------------------------------------------------
+    // File system
+    // --------------------------------------------------------------------------
+    async readFile(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      return fs.readFile(abs, "utf-8");
+    },
+    async readBytes(filePath, offset, length) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      const fh = await fs.open(abs, "r");
+      try {
+        const buf = Buffer.alloc(length);
+        await fh.read(buf, 0, length, offset);
+        return buf;
+      } finally {
+        await fh.close();
+      }
+    },
+    async writeFile(filePath, content) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      await fs.mkdir(path.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, content, "utf-8");
+    },
+    async exists(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      return existsSync(abs);
+    },
+    async stat(filePath) {
+      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      const s = await fs.stat(abs);
+      return {
+        size: s.size,
+        mtime: s.mtime,
+        isDirectory: s.isDirectory(),
+        isFile: s.isFile()
+      };
+    },
+    async readdir(dirPath) {
+      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+      const entries = await fs.readdir(abs, { withFileTypes: true });
+      return entries.map((e) => ({
+        name: e.name,
+        isDirectory: e.isDirectory(),
+        isFile: e.isFile()
+      }));
+    },
+    async mkdir(dirPath) {
+      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
+      await fs.mkdir(abs, { recursive: true });
+    },
+    // --------------------------------------------------------------------------
+    // Process execution
+    // --------------------------------------------------------------------------
+    exec(command, options) {
+      const { shell, args } = getShell();
+      const execCwd = options?.cwd ?? cwd;
+      const env = {
+        ...process.env,
+        ...options?.env,
+        // Disable pagers — tools collect output, not interactive
+        PAGER: "cat",
+        GIT_PAGER: "cat"
+      };
+      return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let settled = false;
+        const child = spawn(shell, [...args, command], {
+          cwd: execCwd,
+          detached: process.platform !== "win32",
+          env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        child.stdout?.on("data", (data) => {
+          stdout += data.toString();
+          options?.onStdout?.(data);
+        });
+        child.stderr?.on("data", (data) => {
+          stderr += data.toString();
+          options?.onStderr?.(data);
+        });
+        let timer;
+        if (options?.timeout && options.timeout > 0) {
+          timer = setTimeout(() => {
+            timedOut = true;
+            if (child.pid) killProcessTree(child.pid);
+          }, options.timeout);
+        }
+        const onAbort = () => {
+          if (child.pid) killProcessTree(child.pid);
+        };
+        options?.signal?.addEventListener("abort", onAbort, { once: true });
+        child.on("close", (code) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          options?.signal?.removeEventListener("abort", onAbort);
+          resolve({ stdout, stderr, exitCode: code, timedOut });
+        });
+        child.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          if (timer) clearTimeout(timer);
+          options?.signal?.removeEventListener("abort", onAbort);
+          reject(err);
+        });
+      });
+    }
+  };
+}
+
+// src/tool/host/registry.ts
+var ToolHostRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    this.providers.set(provider.name, provider);
+    return this;
+  }
+  unregister(name) {
+    return this.providers.delete(name);
+  }
+  get(name) {
+    return this.providers.get(name);
+  }
+  list() {
+    return Array.from(this.providers.values()).map((provider) => ({
+      name: provider.name,
+      description: provider.description
+    }));
+  }
+  async create(name, options) {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      throw new Error(`Unknown tool host provider "${name}"`);
+    }
+    return await provider.create(options);
+  }
+};
+
+// src/tool/host/index.ts
+var defaultToolHostRegistry = new ToolHostRegistry().register({
+  name: "local",
+  description: "Run tools on the local machine.",
+  create: (options) => localHost(options?.cwd)
+});
+
+export {
+  localHost,
+  ToolHostRegistry,
+  defaultToolHostRegistry
+};

package/dist/dispatch/index.d.ts

@@ -0,0 +1,93 @@
+import { br as LocalDispatchRuntimeOptions, aU as DispatchRuntime, T as Tool, cY as TaskExecutorInput, cX as TaskExecutor, aR as DispatchRecord, aY as DispatchTargetInspection, aX as DispatchTarget, dd as TeamTask, bw as MemberRuntime, a_ as DispatchTargetStartResult, a$ as DispatchTargetSummary, b7 as ExternalTaskControl } from '../instance-BqV2D5pc.js';
+export { aI as DEFAULT_DISPATCH_TOOL_IDS, aJ as DEFAULT_LOCAL_DISPATCH_CONCURRENCY, aK as DEFAULT_LOCAL_DISPATCH_DEPTH, aL as DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX, aO as DISPATCH_STATES, aP as DispatchCheckOptions, aQ as DispatchListOptions, aS as DispatchResult, aT as DispatchRole, aV as DispatchStartInput, aW as DispatchState, aZ as DispatchTargetStartInput, b0 as DispatchUsage } from '../instance-BqV2D5pc.js';
+import '../types-C_LCeYNg.js';
+import 'ai';
+import '../types-RSCv7nQ4.js';
+import 'zod';
+import '../types-CQaXbRsS.js';
+import '../types-Bj_J8u_W.js';
+import '@ai-sdk/provider-utils';
+import '../sandbox/index.js';
+import '../llm-error-D93FNNLY.js';
+
+/**
+ * Local in-process DispatchRuntime.
+ *
+ * Launches child agents as background async tasks, tracks them in a Map,
+ * and supports redirect (via `agent.intervene()`), cancel (via
+ * AbortController), and status polling.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create a local in-process `DispatchRuntime`.
+ *
+ * This is the simplest runtime — child agents are forked from the parent
+ * and run as background Promise tasks in the same process. Use
+ * `createDaprDispatchRuntime()` for durable distributed dispatch.
+ */
+declare function createLocalDispatchRuntime(options: LocalDispatchRuntimeOptions): DispatchRuntime;
+
+/**
+ * Create the standard dispatch tools from a `DispatchRuntime`.
+ *
+ * Returns `start_dispatch`, `check_dispatch`, `redirect_dispatch`,
+ * `cancel_dispatch`, and `list_dispatches`.
+ */
+declare function createDispatchTools(runtime: DispatchRuntime): Tool.AnyInfo[];
+
+interface DispatchTaskExecutorOptions<RecordT extends DispatchRecord = DispatchRecord, InspectionT extends DispatchTargetInspection = DispatchTargetInspection> {
+    targets: readonly DispatchTarget<RecordT, InspectionT>[];
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    now?: () => string;
+    resolveTargetName?: (input: TaskExecutorInput) => string;
+    createRecord?: (input: {
+        taskInput: TaskExecutorInput;
+        target: DispatchTarget<RecordT, InspectionT>;
+        dispatchId: string;
+        startedAt: string;
+        startResult: DispatchTargetStartResult;
+    }) => RecordT;
+}
+interface DispatchExternalTaskControlOptions<RecordT extends DispatchRecord = DispatchRecord, InspectionT extends DispatchTargetInspection = DispatchTargetInspection> {
+    targets: readonly DispatchTarget<RecordT, InspectionT>[];
+    now?: () => string;
+    resolveTargetName?: (input: {
+        task: TeamTask;
+        runtime: MemberRuntime;
+    }) => string;
+    createRecord?: (input: {
+        task: TeamTask;
+        runtime: MemberRuntime;
+        target: DispatchTarget<RecordT, InspectionT>;
+        dispatchId: string;
+        startedAt: string;
+    }) => RecordT;
+}
+interface DispatchTaskExecutorRoute {
+    matches(input: TaskExecutorInput): boolean;
+    executor: TaskExecutor;
+}
+interface CompositeDispatchTaskExecutorOptions {
+    routes: readonly DispatchTaskExecutorRoute[];
+    fallback?: TaskExecutor;
+}
+interface RuntimeDispatchTargetOptions {
+    runtime: DispatchRuntime;
+    filter?: (target: DispatchTargetSummary) => boolean;
+}
+interface RuntimeDispatchExecutorOptions extends Omit<DispatchTaskExecutorOptions, "targets"> {
+    runtime: DispatchRuntime;
+    filter?: (target: DispatchTargetSummary) => boolean;
+}
+declare function ensureNonEmpty(input: string, label: string): string;
+declare function mergeInspection<RecordT extends DispatchRecord, InspectionT extends DispatchTargetInspection>(record: RecordT, inspection: InspectionT | undefined, fallbackNow: string): RecordT;
+declare function createRuntimeDispatchTargets(options: RuntimeDispatchTargetOptions): DispatchTarget[];
+declare function createDispatchTaskExecutor<RecordT extends DispatchRecord = DispatchRecord, InspectionT extends DispatchTargetInspection = DispatchTargetInspection>(options: DispatchTaskExecutorOptions<RecordT, InspectionT>): TaskExecutor;
+declare function createCompositeDispatchTaskExecutor(options: CompositeDispatchTaskExecutorOptions): TaskExecutor;
+declare function createRuntimeDispatchExecutor(options: RuntimeDispatchExecutorOptions): TaskExecutor;
+declare function createDispatchExternalTaskControl<RecordT extends DispatchRecord = DispatchRecord, InspectionT extends DispatchTargetInspection = DispatchTargetInspection>(options: DispatchExternalTaskControlOptions<RecordT, InspectionT>): ExternalTaskControl;
+
+export { type CompositeDispatchTaskExecutorOptions, type DispatchExternalTaskControlOptions, DispatchRecord, DispatchRuntime, DispatchTarget, DispatchTargetInspection, DispatchTargetStartResult, DispatchTargetSummary, type DispatchTaskExecutorOptions, type DispatchTaskExecutorRoute, LocalDispatchRuntimeOptions, type RuntimeDispatchExecutorOptions, type RuntimeDispatchTargetOptions, createCompositeDispatchTaskExecutor, createDispatchExternalTaskControl, createDispatchTaskExecutor, createDispatchTools, createLocalDispatchRuntime, createRuntimeDispatchExecutor, createRuntimeDispatchTargets, ensureNonEmpty, mergeInspection };

package/dist/dispatch/index.js

@@ -0,0 +1,37 @@
+import {
+  createCompositeDispatchTaskExecutor,
+  createDispatchExternalTaskControl,
+  createDispatchTaskExecutor,
+  createRuntimeDispatchExecutor,
+  createRuntimeDispatchTargets,
+  ensureNonEmpty,
+  mergeInspection
+} from "../chunk-5FMSGQVX.js";
+import {
+  DEFAULT_DISPATCH_TOOL_IDS,
+  DEFAULT_LOCAL_DISPATCH_CONCURRENCY,
+  DEFAULT_LOCAL_DISPATCH_DEPTH,
+  DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
+  DISPATCH_STATES,
+  createDispatchTools,
+  createLocalDispatchRuntime
+} from "../chunk-SSFBF3US.js";
+import "../chunk-SZ2XBPTW.js";
+import "../chunk-Q742PSH3.js";
+import "../chunk-ICZ66572.js";
+export {
+  DEFAULT_DISPATCH_TOOL_IDS,
+  DEFAULT_LOCAL_DISPATCH_CONCURRENCY,
+  DEFAULT_LOCAL_DISPATCH_DEPTH,
+  DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
+  DISPATCH_STATES,
+  createCompositeDispatchTaskExecutor,
+  createDispatchExternalTaskControl,
+  createDispatchTaskExecutor,
+  createDispatchTools,
+  createLocalDispatchRuntime,
+  createRuntimeDispatchExecutor,
+  createRuntimeDispatchTargets,
+  ensureNonEmpty,
+  mergeInspection
+};

package/dist/events/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * EventBus — channel-based event streaming interface.
+ *
+ * Defines how events are published and consumed in a channel-keyed
+ * pub/sub model. The default implementation (`createEventBus`) is
+ * in-process with history replay. A distributed runtime can supply
+ * its own implementation that bridges to external infrastructure
+ * (e.g. Dapr pub/sub, Redis Streams, Kafka).
+ *
+ * Each channel is typically a session ID or workflow instance ID.
+ * Events flow from producers (workflow activities, agent execution)
+ * to consumers (SSE endpoints, WebSocket connections, TUI renderers).
+ */
+interface EventBusMessage {
+    /** Channel this message was published to. */
+    channel: string;
+    /** Event type — matches AgentEvent.type for agent events. */
+    type: string;
+    /** Serializable event payload. */
+    data: unknown;
+    /** Monotonically increasing sequence within the channel. */
+    seq: number;
+}
+interface EventBusSubscription {
+    /** Async iterator that yields events as they arrive. */
+    [Symbol.asyncIterator](): AsyncIterableIterator<EventBusMessage>;
+    /** Stop receiving events. Safe to call multiple times. */
+    unsubscribe(): void;
+}
+interface EventBusSubscribeOptions {
+    /**
+     * Replay messages strictly after this sequence number.
+     * Used to implement SSE resume via `Last-Event-ID`.
+     */
+    afterSeq?: number;
+}
+interface EventBusOptions {
+    /**
+     * Maximum retained messages per channel for replay.
+     * Older messages are dropped from the head of the history buffer.
+     */
+    maxHistoryMessages?: number;
+    /**
+     * Maximum buffered live messages per subscriber before the subscriber
+     * is disconnected to avoid unbounded memory growth.
+     */
+    maxBufferedMessages?: number;
+    /**
+     * How long (ms) to retain channel history with no active subscribers
+     * so reconnecting clients can resume after transient disconnects.
+     */
+    channelRetentionMs?: number;
+}
+interface EventBus {
+    /**
+     * Publish an event to all subscribers of `channel`.
+     * Non-blocking — if no one is listening the event is still retained
+     * in the channel history for replay.
+     */
+    publish(channel: string, type: string, data: unknown): void;
+    /**
+     * Subscribe to events on `channel`. Returns an async iterable that
+     * yields events as they arrive and completes when `close(channel)` is
+     * called or the subscription is unsubscribed.
+     */
+    subscribe(channel: string, options?: EventBusSubscribeOptions): EventBusSubscription;
+    /**
+     * Close a channel. All active subscriptions complete their iterators.
+     * Subsequent publishes to this channel start a fresh stream.
+     */
+    close(channel: string, finalEvent?: {
+        type: string;
+        data: unknown;
+    }): void;
+    /** Number of active channels (channels with at least one subscriber). */
+    readonly activeChannels: number;
+}
+
+/**
+ * In-process EventBus implementation.
+ *
+ * Events are published by producers and consumed by subscribers via
+ * async iterators. Each channel maintains a history buffer for replay
+ * (e.g. SSE `Last-Event-ID` resume). Channels are automatically
+ * cleaned up after a configurable retention period with no subscribers.
+ */
+
+/**
+ * Create a new in-process event bus.
+ */
+declare function createEventBus(options?: EventBusOptions): EventBus;
+
+export { type EventBus, type EventBusMessage, type EventBusOptions, type EventBusSubscribeOptions, type EventBusSubscription, createEventBus };

package/dist/events/index.js

@@ -0,0 +1,6 @@
+import {
+  createEventBus
+} from "../chunk-2TTOLHBT.js";
+export {
+  createEventBus
+};