@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/chunk-SSFBF3US.js

@@ -0,0 +1,602 @@
+import {
+  Tool
+} from "./chunk-Q742PSH3.js";
+import {
+  buildEntryPath,
+  deserializeMessage
+} from "./chunk-ICZ66572.js";
+
+// src/agent/session.ts
+async function ensureSessionLoaded(options) {
+  const { sessionId, sessions, cwd } = options;
+  if (sessions.getSessionId() === sessionId) {
+    return;
+  }
+  const exists = await sessions.sessionExists(sessionId);
+  if (exists) {
+    await sessions.load(sessionId);
+  } else {
+    await sessions.create({ id: sessionId, cwd });
+  }
+}
+async function repairOrphanedToolCalls(sessions) {
+  const messages = sessions.getMessages();
+  const pendingCallIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
+      }
+    }
+    if (message.role === "tool" && message.toolCallId) {
+      pendingCallIds.delete(message.toolCallId);
+    }
+  }
+  for (const [toolCallId, { toolName }] of pendingCallIds) {
+    const toolMessage = {
+      id: crypto.randomUUID(),
+      role: "tool",
+      content: "Error: tool execution failed (result was not recorded)",
+      toolCallId,
+      toolName,
+      result: "Error: tool execution failed (result was not recorded)",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await sessions.addMessage(toolMessage);
+  }
+}
+async function createSubAgentRunSession(options) {
+  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
+  await options.sessions.create({
+    id: sessionId,
+    cwd: options.cwd,
+    title: options.title ?? "Sub-agent task",
+    parentSessionId: options.parentSessionId
+  });
+  return sessionId;
+}
+function getVisibleSessionMessages(sessions) {
+  const leafId = sessions.getLeafId();
+  if (!leafId) {
+    return [];
+  }
+  const path = buildEntryPath(
+    sessions.getEntries(),
+    leafId
+  );
+  const visible = [];
+  let skipUntilId;
+  for (const entry of path) {
+    if (entry.type === "compaction") {
+      visible.push({
+        id: entry.id,
+        role: "system",
+        content: `## Previous Conversation Summary
+
+${entry.summary}`,
+        createdAt: new Date(entry.timestamp)
+      });
+      skipUntilId = entry.firstKeptEntryId !== entry.id ? entry.firstKeptEntryId : void 0;
+      continue;
+    }
+    if (skipUntilId && entry.id !== skipUntilId) {
+      continue;
+    }
+    if (entry.id === skipUntilId) {
+      skipUntilId = void 0;
+    }
+    if (entry.type === "message") {
+      visible.push(deserializeMessage(entry.message));
+    }
+  }
+  return visible;
+}
+
+// src/dispatch/types.ts
+var DISPATCH_STATES = [
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var DEFAULT_DISPATCH_TOOL_IDS = [
+  "start_dispatch",
+  "check_dispatch",
+  "redirect_dispatch",
+  "cancel_dispatch",
+  "list_dispatches"
+];
+var DEFAULT_LOCAL_DISPATCH_CONCURRENCY = 6;
+var DEFAULT_LOCAL_DISPATCH_DEPTH = 2;
+var DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX = "Dispatch";
+
+// src/dispatch/tool-factories.ts
+import { z } from "zod";
+
+// src/dispatch/results.ts
+function formatStatus(record) {
+  const parts = [
+    `ID: ${record.id}`,
+    `Target: ${record.targetType}`,
+    `Status: ${record.status}`
+  ];
+  if (record.title) {
+    parts.push(`Title: ${record.title}`);
+  }
+  if (record.sessionId) {
+    parts.push(`Session: ${record.sessionId}`);
+  }
+  if (record.redirectCount > 0) {
+    parts.push(`Redirects: ${record.redirectCount}`);
+  }
+  if (record.result) {
+    parts.push(`Response: ${record.result.response}`);
+  }
+  if (record.error) {
+    parts.push(`Error: ${record.error}`);
+  }
+  return parts.join("\n");
+}
+function formatDispatchStarted(record) {
+  return {
+    title: `Dispatch started: ${record.targetType}`,
+    output: `Dispatch started successfully.
+
+` + formatStatus(record) + `
+
+Use \`check_dispatch\` with ID "${record.id}" to monitor progress.`,
+    metadata: {
+      dispatchId: record.id,
+      targetType: record.targetType,
+      sessionId: record.sessionId
+    }
+  };
+}
+function formatDispatchChecked(record) {
+  return {
+    title: `Dispatch ${record.status}: ${record.targetType}`,
+    output: formatStatus(record),
+    metadata: {
+      dispatchId: record.id,
+      targetType: record.targetType,
+      status: record.status
+    }
+  };
+}
+function formatDispatchRedirected(record) {
+  return {
+    title: `Dispatch redirected: ${record.targetType}`,
+    output: `Dispatch "${record.id}" has been redirected.
+
+` + formatStatus(record),
+    metadata: {
+      dispatchId: record.id,
+      targetType: record.targetType,
+      redirectCount: record.redirectCount
+    }
+  };
+}
+function formatDispatchCancelled(record) {
+  return {
+    title: `Dispatch cancelled: ${record.targetType}`,
+    output: `Dispatch "${record.id}" has been cancelled.
+
+` + formatStatus(record),
+    metadata: {
+      dispatchId: record.id,
+      targetType: record.targetType
+    }
+  };
+}
+function formatDispatchList(records) {
+  if (records.length === 0) {
+    return {
+      title: "No dispatches",
+      output: "No dispatches match the given criteria.",
+      metadata: { count: 0 }
+    };
+  }
+  const lines = records.map(
+    (record) => `- ${record.id} [${record.status}] ${record.targetType}: ${record.title || record.brief}`
+  );
+  return {
+    title: `${records.length} dispatch(es)`,
+    output: lines.join("\n"),
+    metadata: { count: records.length }
+  };
+}
+function formatDispatchError(label, error) {
+  return {
+    title: "Dispatch error",
+    output: `${label}: ` + (error instanceof Error ? error.message : String(error)),
+    metadata: { error: true }
+  };
+}
+
+// src/dispatch/tool-factories.ts
+function buildTargetDescription(targets) {
+  const list = targets.map((target) => `  - "${target.name}": ${target.description}`).join("\n");
+  return `Available targets:
+${list}`;
+}
+function createDispatchStartTool(runtime) {
+  const targets = runtime.describeTargets();
+  const targetNames = targets.map((target) => target.name);
+  return Tool.define("start_dispatch", {
+    description: `Start a new background dispatch.
+
+` + buildTargetDescription(targets) + `
+
+Use \`check_dispatch\` to monitor progress after starting.`,
+    parameters: z.object({
+      targetType: z.string().describe(
+        `The target to dispatch to. Must be one of: ${targetNames.join(", ")}`
+      ),
+      brief: z.string().describe("Detailed instructions for the dispatch target."),
+      title: z.string().optional().describe("Short title for tracking."),
+      parentSessionId: z.string().optional().describe("Parent session ID for context linking.")
+    }),
+    execute: async (params) => {
+      try {
+        const record = await runtime.start({
+          targetType: params.targetType,
+          brief: params.brief,
+          title: params.title,
+          parentSessionId: params.parentSessionId
+        });
+        return formatDispatchStarted(record);
+      } catch (error) {
+        return formatDispatchError("Failed to start dispatch", error);
+      }
+    }
+  });
+}
+function createDispatchCheckTool(runtime) {
+  return Tool.define("check_dispatch", {
+    description: "Check the status of a running dispatch. Returns current status, and result or error if completed or failed.",
+    parameters: z.object({
+      id: z.string().describe("The dispatch ID to check."),
+      waitMs: z.number().optional().describe("Optional time to wait for completion (milliseconds).")
+    }),
+    execute: async (params) => {
+      try {
+        const record = await runtime.check(params.id, {
+          waitMs: params.waitMs
+        });
+        if (!record) {
+          return formatDispatchError(
+            "Dispatch not found",
+            new Error(`No dispatch with ID "${params.id}".`)
+          );
+        }
+        return formatDispatchChecked(record);
+      } catch (error) {
+        return formatDispatchError("Failed to inspect dispatch", error);
+      }
+    }
+  });
+}
+function createDispatchRedirectTool(runtime) {
+  return Tool.define("redirect_dispatch", {
+    description: "Send a steering message to a running dispatch. Use this to narrow scope, add context, or change direction mid-run.",
+    parameters: z.object({
+      id: z.string().describe("The dispatch ID to redirect."),
+      message: z.string().describe("The steering message.")
+    }),
+    execute: async (params) => {
+      try {
+        const record = await runtime.redirect(params.id, params.message);
+        return formatDispatchRedirected(record);
+      } catch (error) {
+        return formatDispatchError("Failed to redirect dispatch", error);
+      }
+    }
+  });
+}
+function createDispatchCancelTool(runtime) {
+  return Tool.define("cancel_dispatch", {
+    description: "Cancel a running dispatch. Use when the result is no longer needed.",
+    parameters: z.object({
+      id: z.string().describe("The dispatch ID to cancel."),
+      reason: z.string().optional().describe("Reason for cancellation.")
+    }),
+    execute: async (params) => {
+      try {
+        const record = await runtime.cancel(params.id, params.reason);
+        return formatDispatchCancelled(record);
+      } catch (error) {
+        return formatDispatchError("Failed to cancel dispatch", error);
+      }
+    }
+  });
+}
+function createDispatchListTool(runtime) {
+  return Tool.define("list_dispatches", {
+    description: "List dispatches, optionally filtered by status, target type, or parent session.",
+    parameters: z.object({
+      status: z.string().optional().describe(
+        'Filter by status: "running", "completed", "failed", "cancelled".'
+      ),
+      targetType: z.string().optional().describe("Filter by target type."),
+      parentSessionId: z.string().optional().describe("Filter by parent session.")
+    }),
+    execute: async (params) => {
+      try {
+        const records = await runtime.list({
+          status: params.status,
+          targetType: params.targetType,
+          parentSessionId: params.parentSessionId
+        });
+        return formatDispatchList(records);
+      } catch (error) {
+        return formatDispatchError("Failed to list dispatches", error);
+      }
+    }
+  });
+}
+
+// src/dispatch/tools.ts
+function createDispatchTools(runtime) {
+  return [
+    createDispatchStartTool(runtime),
+    createDispatchCheckTool(runtime),
+    createDispatchRedirectTool(runtime),
+    createDispatchCancelTool(runtime),
+    createDispatchListTool(runtime)
+  ];
+}
+
+// src/dispatch/runtime.ts
+import { randomUUID } from "crypto";
+function allowsFurtherDispatch(role) {
+  return role.allowFurtherDispatch ?? false;
+}
+function buildRoleChild(parent, role) {
+  const forkOptions = {};
+  if (role.profile) {
+    forkOptions.profile = role.profile;
+  }
+  if (role.systemPrompt) {
+    forkOptions.systemPrompt = role.systemPrompt;
+  }
+  if (role.model) {
+    forkOptions.model = role.model;
+  }
+  if (role.maxSteps) {
+    forkOptions.maxSteps = role.maxSteps;
+  }
+  if (role.additionalMiddleware) {
+    forkOptions.additionalMiddleware = role.additionalMiddleware;
+  }
+  if (role.additionalTools && role.additionalTools.length > 0) {
+    const profileChild = parent.fork(forkOptions);
+    forkOptions.tools = [...profileChild.getTools(), ...role.additionalTools];
+    return parent.fork(forkOptions);
+  }
+  return parent.fork(forkOptions);
+}
+function createLocalDispatchRuntime(options) {
+  const {
+    parent,
+    roles,
+    maxConcurrent = DEFAULT_LOCAL_DISPATCH_CONCURRENCY,
+    maxDepth = DEFAULT_LOCAL_DISPATCH_DEPTH,
+    currentDepth = 0,
+    sessionTitlePrefix = DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
+    now = () => (/* @__PURE__ */ new Date()).toISOString(),
+    createId = () => randomUUID(),
+    childToolIds = DEFAULT_DISPATCH_TOOL_IDS,
+    createChildTools = createDispatchTools,
+    buildChild: customBuildChild
+  } = options;
+  const dispatches = /* @__PURE__ */ new Map();
+  const roleIndex = new Map(roles.map((role) => [role.name, role]));
+  function buildChild(role) {
+    const child = customBuildChild ? customBuildChild(parent, role) : buildRoleChild(parent, role);
+    for (const toolId of childToolIds) {
+      child.removeTool?.(toolId);
+    }
+    if (allowsFurtherDispatch(role) && currentDepth + 1 < maxDepth) {
+      const childRuntime = createLocalDispatchRuntime({
+        parent: child,
+        roles,
+        maxConcurrent,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        sessionTitlePrefix,
+        now,
+        createId,
+        childToolIds,
+        createChildTools,
+        buildChild: customBuildChild
+      });
+      for (const tool of createChildTools(childRuntime)) {
+        child.addTool(tool);
+      }
+    }
+    return child;
+  }
+  function describeTargets() {
+    return roles.map((role) => ({
+      name: role.name,
+      description: role.description
+    }));
+  }
+  async function start(input) {
+    const role = roleIndex.get(input.targetType);
+    if (!role) {
+      throw new Error(
+        `Unknown dispatch target "${input.targetType}". Available: ${[...roleIndex.keys()].join(", ")}`
+      );
+    }
+    if (currentDepth >= maxDepth) {
+      throw new Error(
+        `Dispatch depth limit reached (${currentDepth}/${maxDepth}). Cannot create further child dispatches.`
+      );
+    }
+    const runningCount = [...dispatches.values()].filter(
+      (d) => d.record.status === "running"
+    ).length;
+    if (runningCount >= maxConcurrent) {
+      throw new Error(
+        `Concurrency limit reached (${runningCount}/${maxConcurrent}). Cancel or wait for running dispatches.`
+      );
+    }
+    const id = createId();
+    const child = buildChild(role);
+    const abort = new AbortController();
+    const timestamp = now();
+    const title = input.title ?? `${sessionTitlePrefix}: ${role.name}`;
+    if (input.abort) {
+      if (input.abort.aborted) {
+        abort.abort(input.abort.reason);
+      } else {
+        input.abort.addEventListener(
+          "abort",
+          () => abort.abort(input.abort?.reason),
+          { once: true }
+        );
+      }
+    }
+    const sessionId = await createSubAgentRunSession({
+      sessions: child.getSessionManager(),
+      cwd: child.cwd,
+      parentSessionId: input.parentSessionId,
+      title
+    });
+    const record = {
+      id,
+      targetType: input.targetType,
+      title,
+      brief: input.brief,
+      status: "running",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      parentSessionId: input.parentSessionId,
+      sessionId,
+      executionId: id,
+      redirectCount: 0
+    };
+    const promise = (async () => {
+      try {
+        const result = await child.send(sessionId, input.brief, {
+          abort: abort.signal
+        });
+        const active = dispatches.get(id);
+        if (active && active.record.status === "running") {
+          active.record.status = "completed";
+          active.record.updatedAt = now();
+          active.record.result = {
+            response: result.response,
+            usage: {
+              inputTokens: result.usage?.inputTokens ?? 0,
+              outputTokens: result.usage?.outputTokens ?? 0,
+              totalTokens: result.usage?.totalTokens ?? 0
+            },
+            toolCalls: result.toolCalls ?? []
+          };
+        }
+      } catch (error) {
+        const active = dispatches.get(id);
+        if (active && active.record.status === "running") {
+          if (abort.signal.aborted) {
+            active.record.status = "cancelled";
+          } else {
+            active.record.status = "failed";
+            active.record.error = error instanceof Error ? error.message : String(error);
+          }
+          active.record.updatedAt = now();
+        }
+      }
+    })();
+    dispatches.set(id, { record, child, abort, promise });
+    return { ...record };
+  }
+  async function check(id, options2) {
+    const active = dispatches.get(id);
+    if (!active) {
+      return void 0;
+    }
+    if (active.record.status === "running" && options2?.waitMs) {
+      await Promise.race([
+        active.promise,
+        new Promise(
+          (resolve) => setTimeout(resolve, options2.waitMs)
+        )
+      ]);
+    }
+    return { ...active.record };
+  }
+  async function redirect(id, message) {
+    const active = dispatches.get(id);
+    if (!active) {
+      throw new Error(`No dispatch with ID "${id}".`);
+    }
+    if (active.record.status !== "running") {
+      throw new Error(
+        `Cannot redirect dispatch "${id}" \u2014 status is "${active.record.status}".`
+      );
+    }
+    active.child.intervene(message);
+    active.record.redirectCount += 1;
+    active.record.lastRedirect = message;
+    active.record.updatedAt = now();
+    return { ...active.record };
+  }
+  async function cancel(id, reason) {
+    const active = dispatches.get(id);
+    if (!active) {
+      throw new Error(`No dispatch with ID "${id}".`);
+    }
+    if (active.record.status !== "running") {
+      return { ...active.record };
+    }
+    active.abort.abort(reason ?? "Cancelled");
+    active.record.status = "cancelled";
+    active.record.updatedAt = now();
+    if (reason) {
+      active.record.error = reason;
+    }
+    return { ...active.record };
+  }
+  async function list(options2) {
+    let records = [...dispatches.values()].map((d) => ({ ...d.record }));
+    if (options2?.status) {
+      const statuses = Array.isArray(options2.status) ? options2.status : [options2.status];
+      records = records.filter(
+        (r) => statuses.includes(r.status)
+      );
+    }
+    if (options2?.targetType) {
+      records = records.filter((r) => r.targetType === options2.targetType);
+    }
+    if (options2?.parentSessionId) {
+      records = records.filter(
+        (r) => r.parentSessionId === options2.parentSessionId
+      );
+    }
+    return records;
+  }
+  return {
+    describeTargets,
+    start,
+    check,
+    redirect,
+    cancel,
+    list
+  };
+}
+
+export {
+  ensureSessionLoaded,
+  repairOrphanedToolCalls,
+  createSubAgentRunSession,
+  getVisibleSessionMessages,
+  DISPATCH_STATES,
+  DEFAULT_DISPATCH_TOOL_IDS,
+  DEFAULT_LOCAL_DISPATCH_CONCURRENCY,
+  DEFAULT_LOCAL_DISPATCH_DEPTH,
+  DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
+  createDispatchTools,
+  createLocalDispatchRuntime
+};

package/dist/chunk-SZ2XBPTW.js

@@ -0,0 +1,8 @@
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  sleep
+};