@easynet/agent-runtime 1.0.1

package/src/react-agent.ts

@@ -0,0 +1,576 @@
+import { createAgent as createLangChainAgent } from "langchain";
+import type { BaseMessageLike } from "@langchain/core/messages";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import type { LanguageModelLike } from "@langchain/core/language_models/base";
+import { z } from "zod";
+import { applyToolChoiceAuto } from "@easynet/agent-model";
+import {
+  extractLastMessageText,
+  stripNullishObjectFields,
+  summarizeForLog,
+} from "@easynet/agent-common";
+import type { Skill } from "@easynet/agent-skill";
+import type { BaseAppConfig, BotContext } from "./context.js";
+
+export interface ReactAgentRuntime {
+  agent: unknown;
+  run: (userMessage: string) => Promise<{ text: string; messages?: unknown }>;
+  remember: (content: string, type?: "thread" | "cross_thread" | "knowledge" | "auto") => Promise<void>;
+}
+
+export interface ReactAgentOptions {
+  agentName?: string;
+  systemPrompt?: string;
+  namespace?: string;
+  topK?: number;
+  budgetTokens?: number;
+  maxSteps?: number;
+  printSteps?: boolean;
+  fallbackText?: string;
+  commandWindowLabel?: string;
+  /** LangChain agent middleware (e.g. malformedToolCallMiddleware). */
+  middleware?: unknown[];
+  autoWriteMemory?: boolean;
+  /** Prompted Tool Correction: retry with structured tool feedback. */
+  ptc?: {
+    enabled?: boolean;
+    maxRetries?: number;
+  };
+}
+
+interface MessageLike {
+  type?: string;
+  role?: string;
+  content?: string | unknown;
+  tool_calls?: Array<{ name?: string; args?: unknown; id?: string }>;
+  name?: string;
+  tool_call_id?: string;
+}
+
+type RuntimeTool = {
+  name: string;
+  description?: string;
+  schema: Record<string, unknown>;
+  invoke: (args: unknown) => Promise<unknown>;
+};
+
+interface ToolRunStats {
+  invoked: number;
+  succeeded: number;
+  failed: number;
+  lastError?: string;
+}
+
+function toMessageText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((block) => {
+        if (typeof block === "string") return block;
+        if (typeof block === "object" && block !== null && "text" in block) {
+          const text = (block as { text?: unknown }).text;
+          return typeof text === "string" ? text : "";
+        }
+        return "";
+      })
+      .join("");
+  }
+  return "";
+}
+
+function inferMemoryTypeByStructure(content: string): "thread" | "cross_thread" {
+  const text = content.trim();
+  if (!text) return "thread";
+
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const lineCount = lines.length;
+  const uniqueLineCount = new Set(lines).size;
+  const duplicateRatio = lineCount > 0 ? 1 - uniqueLineCount / lineCount : 0;
+  const symbolCount = (text.match(/[^\p{L}\p{N}\s]/gu) ?? []).length;
+  const symbolRatio = symbolCount / Math.max(1, text.length);
+
+  // Terminal/log-like content is usually long, repetitive, and symbol-dense.
+  if (text.length > 1200) return "thread";
+  if (lineCount > 18) return "thread";
+  if (duplicateRatio > 0.35) return "thread";
+  if (symbolRatio > 0.22) return "thread";
+
+  return "cross_thread";
+}
+
+async function inferMemoryTypeWithModel(
+  llm: LanguageModelLike,
+  content: string
+): Promise<"thread" | "cross_thread" | null> {
+  const classifierPrompt = [
+    "Classify memory scope for an AI agent.",
+    "Return strict JSON only: {\"type\":\"thread|cross_thread\",\"confidence\":0..1}.",
+    "Decision policy:",
+    "- thread: temporary session context, command output, logs, transient task state, step-by-step investigation details.",
+    "- cross_thread: stable user preferences, durable profile facts, long-lived constraints reusable in future sessions.",
+    "Use semantic judgment, not keyword matching.",
+  ].join("\n");
+
+  try {
+    const response = await llm.invoke([
+      { role: "system", content: classifierPrompt },
+      { role: "user", content },
+    ]);
+    const text = toMessageText((response as { content?: unknown }).content).trim();
+    const jsonBlob = text.match(/\{[\s\S]*\}/)?.[0] ?? text;
+    const parsed = JSON.parse(jsonBlob) as { type?: unknown; confidence?: unknown };
+    const type = parsed.type === "thread" || parsed.type === "cross_thread" ? parsed.type : null;
+    const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
+    if (!type) return null;
+    return confidence >= 0.6 ? type : null;
+  } catch {
+    return null;
+  }
+}
+
+function deriveFallbackTextFromMessages(
+  messages: BaseMessageLike[],
+  opts: { fallbackText: string; commandWindowLabel?: string }
+): string {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i] as MessageLike;
+    const type = msg?.type ?? msg?.role ?? "";
+    if (type !== "tool" && !msg?.tool_call_id) continue;
+
+    const raw =
+      typeof msg.content === "string"
+        ? msg.content
+        : msg.content != null
+          ? String(msg.content)
+          : "";
+    if (!raw.trim()) continue;
+
+    try {
+      const parsed = JSON.parse(raw) as {
+        result?: {
+          command?: string;
+          windowId?: number;
+          tabIndex?: number;
+          to?: string;
+          serviceType?: string;
+        };
+        evidence?: Array<{ summary?: string }>;
+      };
+
+      const summary = parsed.evidence?.find((e) => e?.summary)?.summary;
+      if (typeof summary === "string" && summary.trim()) return summary.trim();
+
+      const to = parsed.result?.to?.trim();
+      const serviceType = parsed.result?.serviceType?.trim();
+      if (to) {
+        return serviceType ? `Sent ${serviceType} message to ${to}.` : `Sent message to ${to}.`;
+      }
+
+      const command = parsed.result?.command?.trim();
+      if (command) {
+        const w = parsed.result?.windowId;
+        const t = parsed.result?.tabIndex;
+        if (typeof w === "number" && typeof t === "number") {
+          const label = opts.commandWindowLabel ?? "window";
+          return `Executed command in ${label} ${w}, tab ${t}: ${command}`;
+        }
+        return `Executed command: ${command}`;
+      }
+    } catch {
+      return raw.length > 200 ? raw.slice(0, 200) + "..." : raw;
+    }
+  }
+
+  return opts.fallbackText;
+}
+
+function hasToolMessages(messages: unknown): boolean {
+  const list = Array.isArray(messages) ? messages : [];
+  for (const item of list) {
+    const msg = item as MessageLike;
+    const type = msg?.type ?? msg?.role ?? "";
+    if (type === "tool" || Boolean(msg?.tool_call_id) || (msg?.tool_calls?.length ?? 0) > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function looksLikeToolRefusal(text: string): boolean {
+  const t = text.toLowerCase();
+  return (
+    t.includes("don't have") ||
+    t.includes("do not have") ||
+    t.includes("no direct") ||
+    t.includes("cannot directly") ||
+    t.includes("can't directly") ||
+    t.includes("no tool") ||
+    t.includes("schema") ||
+    t.includes("invalid")
+  );
+}
+
+function extractSchemaKeys(schema: unknown): string[] {
+  if (!schema || typeof schema !== "object") return [];
+  const rec = schema as Record<string, unknown>;
+  const properties = rec.properties;
+  if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+    return Object.keys(properties as Record<string, unknown>);
+  }
+  const shape = rec.shape;
+  if (shape && typeof shape === "object" && !Array.isArray(shape)) {
+    return Object.keys(shape as Record<string, unknown>);
+  }
+  return [];
+}
+
+function buildPtcHint(input: {
+  taskIntent: string;
+  stats: ToolRunStats;
+  toolSignatures: string[];
+}): string {
+  const lines = [
+    "[PTC_FEEDBACK]",
+    `TaskIntent: ${input.taskIntent}`,
+    `ToolStats: invoked=${input.stats.invoked}, succeeded=${input.stats.succeeded}, failed=${input.stats.failed}`,
+    input.stats.lastError ? `LastToolError: ${input.stats.lastError}` : "",
+    "Action: Retry using available tools. Do not claim tools are unavailable.",
+    "Action: If previous tool args were invalid, correct arguments strictly by schema.",
+    "Action: If a tool is needed, emit a valid tool call instead of plain explanation.",
+    `AvailableTools: ${input.toolSignatures.join("; ")}`,
+  ].filter((v) => v.length > 0);
+  return lines.join("\n");
+}
+
+export function printReactSteps(messages: unknown): void {
+  const list = Array.isArray(messages) ? messages : [];
+  let stepIndex = 0;
+  for (let i = 0; i < list.length; i++) {
+    const msg = list[i] as MessageLike;
+    const type = msg?.type ?? msg?.role ?? "";
+    const content = msg?.content;
+    const contentStr =
+      typeof content === "string"
+        ? content
+        : typeof content === "object" && content !== null && Array.isArray(content)
+          ? (content as { type?: string; text?: string }[])
+              .map((b) => ("text" in b ? b.text : JSON.stringify(b)))
+              .join("")
+          : content != null
+            ? String(content)
+            : "";
+
+    if (type === "human" || (type === "user" && !msg.tool_calls)) {
+      if (contentStr.trim()) {
+        console.error(`\n--- Step (user) ---\n${contentStr.trim()}`);
+      }
+      continue;
+    }
+
+    if (type === "ai" || type === "assistant") {
+      if (msg.tool_calls?.length) {
+        stepIndex += 1;
+        if (contentStr.trim()) {
+          console.error(`\n--- ReAct Step ${stepIndex}: Thought ---\n${contentStr.trim()}`);
+        }
+        for (const tc of msg.tool_calls) {
+          const name = tc?.name ?? "?";
+          const args =
+            typeof tc?.args === "object" && tc?.args !== null
+              ? JSON.stringify(tc.args)
+              : String(tc?.args ?? "");
+          console.error(`--- ReAct Step ${stepIndex}: Action ---\n${name}(${args})`);
+        }
+      }
+      continue;
+    }
+
+    if (type === "tool" || msg?.tool_call_id) {
+      const toolName = msg?.name ?? "tool";
+      const obs = contentStr.length > 200 ? contentStr.slice(0, 200) + "..." : contentStr;
+      console.error(`--- ReAct Step ${stepIndex}: Observation (${toolName}) ---\n${obs || "(empty)"}`);
+    }
+  }
+  console.error("");
+}
+
+export function createReactAgent<TConfig extends BaseAppConfig>(
+  ctx: BotContext<TConfig>,
+  options: ReactAgentOptions = {}
+) {
+  const publish = (name: string, from: string, to: string, payload?: unknown) => {
+    ctx.events.publish({ name, from, to, payload });
+  };
+
+  const runtimeTools = ctx.tools as unknown as RuntimeTool[];
+  const agentName = options.agentName ?? "react";
+  const configAgent = ctx.config.app?.agent?.[agentName];
+  const configReact = configAgent;
+  const namespace = options.namespace ?? configReact?.memory?.namespace;
+  const topK = options.topK ?? configReact?.memory?.top_k;
+  const budgetTokens = options.budgetTokens ?? configReact?.memory?.budget_tokens;
+  const promptFromConfig = configReact?.system_prompt;
+  const systemPrompt = options.systemPrompt ?? promptFromConfig;
+  const maxSteps = options.maxSteps ?? configReact?.max_steps;
+  const printSteps = options.printSteps ?? configReact?.print_steps;
+  const fallbackText = options.fallbackText ?? configReact?.fallback_text;
+  const commandWindowLabel =
+    options.commandWindowLabel ?? configReact?.command_window_label;
+  const autoWriteMemory = options.autoWriteMemory ?? (configReact?.memory?.auto_write ?? true);
+  const autoWriteScope = configReact?.memory?.auto_write_scope ?? "thread";
+  const autoWriteMaxChars = configReact?.memory?.auto_write_max_chars ?? 2400;
+  const autoWriteUser = configReact?.memory?.auto_write_user ?? true;
+  const autoWriteAssistant = configReact?.memory?.auto_write_assistant ?? true;
+  const ptcEnabled = options.ptc?.enabled ?? true;
+  const ptcMaxRetries = Math.max(0, options.ptc?.maxRetries ?? 1);
+
+  const usedNames = new Set<string>();
+  const toAlias = (raw: string, index: number): string => {
+    const segments = raw.split(".");
+    // For npm tools (npm.scope.pkg.version.toolName), last segment is the tool name (camelCase).
+    // For file/skill tools (file.skills.disk.usage.investigate), strip the "file.skills." prefix
+    // and rejoin remaining segments with hyphens to reconstruct the original name.
+    let base: string;
+    if (segments[0] === "file" && segments.length > 2) {
+      // Strip "file.<dirName>." prefix (e.g. "file.skills.") and rejoin with hyphens
+      base = segments.slice(2).join("-");
+    } else {
+      base = segments.pop() || `tool_${index + 1}`;
+    }
+    const normalized = base.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 48) || `tool_${index + 1}`;
+    let name = normalized;
+    let n = 2;
+    while (usedNames.has(name)) {
+      name = `${normalized}_${n}`;
+      n += 1;
+    }
+    usedNames.add(name);
+    return name;
+  };
+  let currentToolStats: ToolRunStats | null = null;
+
+  const aliasedTools = runtimeTools.map((tool, idx) => {
+    const alias = toAlias(tool.name, idx);
+    return new DynamicStructuredTool({
+      name: alias,
+      description: tool.description ?? `Tool ${alias}`,
+      schema: tool.schema,
+      func: async (args: unknown) => {
+        const sanitizedArgs = stripNullishObjectFields((args ?? {}) as Record<string, unknown>);
+        if (currentToolStats) currentToolStats.invoked += 1;
+        publish("agent.react.tool.invoke.start", "react-agent", alias, { args: sanitizedArgs });
+        try {
+          const raw = await tool.invoke(sanitizedArgs);
+          if (currentToolStats) currentToolStats.succeeded += 1;
+          publish("agent.react.tool.invoke.done", alias, "react-agent", {
+            result: raw,
+            resultPreview: summarizeForLog(raw),
+          });
+          return typeof raw === "string" ? raw : raw == null ? "" : JSON.stringify(raw);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          if (currentToolStats) {
+            currentToolStats.failed += 1;
+            currentToolStats.lastError = message;
+          }
+          publish("agent.react.tool.invoke.error", alias, "react-agent", { error: message });
+          throw err;
+        }
+      },
+    });
+  });
+  const toolSignatures = aliasedTools.map((tool) => {
+    const keys = extractSchemaKeys((tool as unknown as { schema?: unknown }).schema);
+    return keys.length > 0 ? `${tool.name}(${keys.join(",")})` : `${tool.name}(...)`;
+  });
+
+  // In subagent mode, add an activateSkill tool that reads SKILL.md on demand
+  const allTools = [...aliasedTools];
+  const skillsConfig = ctx.config.app?.agent?.[agentName]?.skills;
+  if (ctx.skillSet && skillsConfig?.mode === "subagent" && ctx.skillSet.list().length > 0) {
+    const skillNames = ctx.skillSet.list().map((s: Skill) => s.name);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- schema generics mismatch
+    allTools.push(
+      new DynamicStructuredTool({
+        name: "activateSkill",
+        description:
+          `Activate a skill by name to get its detailed instructions. Available skills: ${skillNames.join(", ")}`,
+        schema: z.object({
+          skillName: z.enum(skillNames as [string, ...string[]]).describe("Name of the skill to activate"),
+        }),
+        func: async (args: { skillName: string }) => {
+          try {
+            return await ctx.skillSet!.read(args.skillName);
+          } catch (err) {
+            return JSON.stringify({
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        },
+      }) as any,
+    );
+  }
+
+  applyToolChoiceAuto(ctx.llm as Parameters<typeof applyToolChoiceAuto>[0]);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- heavily overloaded createAgent
+  const agent = createLangChainAgent({
+    model: ctx.llm as LanguageModelLike,
+    tools: allTools,
+    systemPrompt,
+    ...(options.middleware?.length ? { middleware: options.middleware } : {}),
+  } as any);
+  const conversationHistory: BaseMessageLike[] = [];
+  const maxHistoryMessages = 24;
+
+  return {
+    agent,
+    async run(userMessage: string): Promise<{ text: string; messages?: unknown }> {
+      publish("agent.react.run.start", "user", "react-agent", { userMessage });
+
+      const injectedText = namespace
+        ? (await ctx.memory.recall({
+            namespace,
+            query: userMessage,
+            ...(typeof topK === "number" ? { topK } : {}),
+            ...(typeof budgetTokens === "number" ? { budgetTokens } : {}),
+          })).injectedText
+        : "";
+
+      // Auto-match skills and inject instructions if matched
+      let skillBlock = "";
+      if (ctx.skillSet) {
+        const skillMatchOptions = {
+          ...(typeof configReact?.skills?.embedding_threshold === "number"
+            ? { embeddingThreshold: configReact.skills.embedding_threshold }
+            : {}),
+          ...(typeof configReact?.skills?.keyword_threshold === "number"
+            ? { keywordThreshold: configReact.skills.keyword_threshold }
+            : {}),
+        };
+        const match = await ctx.skillSet.match(userMessage, skillMatchOptions);
+        if (match) {
+          publish("agent.react.skill.matched", "react-agent", "skill", {
+            skill: match.skill.name,
+            score: match.score,
+          });
+          skillBlock = `[Matched skill: ${match.skill.name}]\nFollow these instructions step by step:\n\n${match.instructions}\n\n`;
+        }
+      }
+
+      const contextBlock = injectedText.trim().length > 0 ? `[Relevant memory]\n${injectedText}\n\n` : "";
+      const effectiveMessage = skillBlock + contextBlock + userMessage;
+
+      const runAttempt = async (messageContent: string) => {
+        const invokeInput = {
+          messages: [...conversationHistory, { role: "user" as const, content: messageContent }],
+        };
+        currentToolStats = { invoked: 0, succeeded: 0, failed: 0 };
+        try {
+          const out =
+            typeof maxSteps === "number"
+              ? await agent.invoke(invokeInput, { recursionLimit: maxSteps })
+              : await agent.invoke(invokeInput);
+          return { out, stats: currentToolStats };
+        } finally {
+          currentToolStats = null;
+        }
+      };
+
+      let { out: result, stats } = await runAttempt(effectiveMessage);
+      let messages = (result as { messages?: unknown } | null | undefined)?.messages ?? result;
+      let extractedText = extractLastMessageText(result).trim();
+
+      if (ptcEnabled && ptcMaxRetries > 0) {
+        let retries = 0;
+        while (retries < ptcMaxRetries) {
+          const noToolActivity = (stats?.invoked ?? 0) === 0 && !hasToolMessages(messages);
+          const onlyToolFailure = (stats?.invoked ?? 0) > 0 && (stats?.succeeded ?? 0) === 0;
+          const refusal = looksLikeToolRefusal(extractedText);
+          if (!noToolActivity && !onlyToolFailure && !refusal) break;
+
+          publish("agent.react.ptc.retry", "react-agent", "react-agent", {
+            retry: retries + 1,
+            reason: noToolActivity ? "no_tool_activity" : onlyToolFailure ? "tool_failed" : "tool_refusal_text",
+            stats,
+          });
+          const ptcHint = buildPtcHint({
+            taskIntent: userMessage,
+            stats: stats ?? { invoked: 0, succeeded: 0, failed: 0 },
+            toolSignatures,
+          });
+          const retried = await runAttempt(`${effectiveMessage}\n\n${ptcHint}`);
+          result = retried.out;
+          stats = retried.stats;
+          messages = (result as { messages?: unknown } | null | undefined)?.messages ?? result;
+          extractedText = extractLastMessageText(result).trim();
+          retries += 1;
+        }
+      }
+
+      if (printSteps === true) {
+        printReactSteps(messages);
+      }
+      const text = extractedText || (fallbackText
+        ? deriveFallbackTextFromMessages((Array.isArray(messages) ? messages : []) as BaseMessageLike[], {
+          fallbackText,
+          commandWindowLabel,
+        })
+        : extractedText);
+      conversationHistory.push({ role: "user", content: userMessage });
+      if (text.trim().length > 0) {
+        conversationHistory.push({ role: "assistant", content: text });
+      }
+      if (conversationHistory.length > maxHistoryMessages) {
+        conversationHistory.splice(0, conversationHistory.length - maxHistoryMessages);
+      }
+
+      if (namespace && autoWriteMemory) {
+        const scope = autoWriteScope === "auto" ? inferMemoryTypeByStructure(`${userMessage}\n${text}`) : autoWriteScope;
+        const writeItems: string[] = [];
+        if (autoWriteUser && userMessage.trim().length > 0) {
+          writeItems.push(`[user]\n${userMessage.trim()}`);
+        }
+        if (autoWriteAssistant && text.trim().length > 0) {
+          writeItems.push(`[assistant]\n${text.trim()}`);
+        }
+        const content = writeItems.join("\n\n").slice(0, Math.max(0, autoWriteMaxChars));
+        if (content.length > 0) {
+          try {
+            publish("agent.react.memory.write.start", "react-agent", "memory", { type: scope, auto: true });
+            await ctx.memory.memorize(namespace, scope, content);
+            publish("agent.react.memory.write.done", "memory", "react-agent", { type: scope, auto: true });
+          } catch (err) {
+            publish("agent.react.memory.write.error", "memory", "react-agent", {
+              auto: true,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        }
+      }
+
+      publish("agent.react.run.done", "react-agent", "user", { text });
+      return { text, messages };
+    },
+    async remember(
+      content: string,
+      type: "thread" | "cross_thread" | "knowledge" | "auto" = "auto"
+    ) {
+      const resolvedType =
+        type === "auto"
+          ? (await inferMemoryTypeWithModel(ctx.llm as LanguageModelLike, content)) ??
+            inferMemoryTypeByStructure(content)
+          : type;
+      publish("agent.react.memory.write.start", "react-agent", "memory", { type: resolvedType });
+      if (!namespace) {
+        publish("agent.react.memory.write.skipped", "react-agent", "memory", {
+          reason: "namespace_not_configured",
+        });
+        return;
+      }
+      await ctx.memory.memorize(namespace, resolvedType, content);
+      publish("agent.react.memory.write.done", "memory", "react-agent", { type: resolvedType });
+    },
+  };
+}

package/src/sub-agent.ts

@@ -0,0 +1,82 @@
+/**
+ * Parent-Child sub-agent pattern.
+ *
+ * A parent agent can spawn child agents (react or deep) that reuse the parent's
+ * BotContext (LLM, tools, memory) but run with their own system prompt and options.
+ * The child runs to completion and returns its result to the parent.
+ */
+import { createReactAgent } from "./react-agent.js";
+import { createDeepAgent } from "./deep-agent.js";
+import { malformedToolCallMiddleware } from "./malformed-tool-call-middleware.js";
+import type { BotContext } from "./context.js";
+
+export interface SubAgentOptions {
+  /** Agent kind: react or deep. */
+  kind: "react" | "deep";
+  /** Agent name from config (default: same as kind). */
+  agentName?: string;
+  /** Override system prompt for this child. */
+  systemPrompt?: string;
+  /** Max steps (react) or recursion limit (deep) for the child. */
+  maxSteps?: number;
+}
+
+export interface SubAgentResult {
+  text: string;
+  messages?: unknown;
+}
+
+export interface SubAgentRunner {
+  /**
+   * Spawn a child agent, run it with the given message, and return the result.
+   * The child reuses the parent's BotContext (LLM, tools, memory, config).
+   */
+  run(message: string, options: SubAgentOptions): Promise<SubAgentResult>;
+}
+
+/**
+ * Create a SubAgentRunner bound to a parent BotContext.
+ *
+ * Usage:
+ * ```ts
+ * const sub = createSubAgentRunner(parentCtx);
+ * const result = await sub.run("Summarize the logs", { kind: "react" });
+ * console.log(result.text);
+ * ```
+ */
+export function createSubAgentRunner(parentCtx: BotContext): SubAgentRunner {
+  const publish = (name: string, from: string, to: string, payload?: unknown) => {
+    parentCtx.events.publish({ name, from, to, payload });
+  };
+
+  return {
+    async run(message: string, options: SubAgentOptions): Promise<SubAgentResult> {
+      const { kind, agentName, systemPrompt, maxSteps } = options;
+      const childName = agentName ?? kind;
+
+      publish("agent.sub.spawn", "parent", childName, { kind, message: message.slice(0, 100) });
+
+      if (kind === "react") {
+        const runtime = createReactAgent(parentCtx, {
+          agentName: childName,
+          systemPrompt,
+          maxSteps,
+          middleware: [malformedToolCallMiddleware()],
+        });
+        const result = await runtime.run(message);
+        publish("agent.sub.done", childName, "parent", { text: result.text.slice(0, 200) });
+        return result;
+      }
+
+      // deep
+      const runtime = await createDeepAgent(parentCtx, {
+        agentName: childName,
+        systemPrompt,
+        recursionLimit: maxSteps,
+      });
+      const result = await runtime.run(message);
+      publish("agent.sub.done", childName, "parent", { text: result.text.slice(0, 200) });
+      return result;
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}