hoomanjs 1.14.0 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoomanjs",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "description": "Hackable Bun-powered AI agent toolkit for building local CLI, ACP, MCP, and channel-driven workflows.",
   "author": {
     "name": "Vaibhav Pandey",

package/src/acp/utils/tool-kind.ts

@@ -14,6 +14,7 @@ const KNOWN_TOOL_KINDS = new Map<string, ToolKind>([
   ["search_files", "search"],
   ["get_file_info", "read"],
   ["shell", "execute"],
+  ["sleep", "other"],
   ["fetch", "fetch"],
   ["wiki_list_files", "read"],
   ["wiki_read_file", "read"],
@@ -22,9 +23,23 @@ const KNOWN_TOOL_KINDS = new Map<string, ToolKind>([
   ["wiki_stats", "read"],
   ["wiki_search", "search"],
   ["think", "think"],
+  ["run_agents", "other"],
   ["update_todos", "other"],
   ["get_current_time", "other"],
   ["convert_time", "other"],
+  ["list_skills", "read"],
+  ["search_skills", "search"],
+  ["install_skill", "edit"],
+  ["delete_skill", "edit"],
+  ["store_memory", "edit"],
+  ["search_memory", "search"],
+  ["update_memory", "edit"],
+  ["archive_memory", "edit"],
+  ["list_mcp_servers", "read"],
+  ["get_mcp_server", "read"],
+  ["add_mcp_server", "edit"],
+  ["update_mcp_server", "edit"],
+  ["delete_mcp_server", "edit"],
 ]);
 
 export { INTERNAL_ALWAYS_ALLOWED };

package/src/cli.ts

@@ -132,6 +132,7 @@ program
         {
           sessionId: session,
           userId: session,
+          mode: "daemon",
         },
         true,
       );

package/src/configure/app.tsx

@@ -46,6 +46,14 @@ import {
   truncate,
 } from "./utils.ts";
 
+const PROMPT_LABELS: Record<keyof ConfigData["prompts"], string> = {
+  behaviour: "Behaviour",
+  communication: "Communication",
+  execution: "Execution",
+  engineering: "Engineering",
+  guardrails: "Guardrails",
+};
+
 export function ConfigureApp({
   config,
   mcpConfig,
@@ -131,6 +139,7 @@ export function ConfigureApp({
       ({
         name: config.name,
         llm: config.llm,
+        prompts: config.prompts,
         tools: config.tools,
         compaction: config.compaction,
       }) satisfies ConfigData,
@@ -369,6 +378,10 @@ export function ConfigureApp({
   };
 
   const renderConfigMenu = () => {
+    const enabledPrompts = Object.values(configData.prompts).filter(
+      Boolean,
+    ).length;
+    const totalPrompts = Object.keys(configData.prompts).length;
     const items: MenuItem[] = [
       {
         label: `Name • ${configData.name}`,
@@ -431,6 +444,10 @@ export function ConfigureApp({
             },
           }),
       },
+      {
+        label: `Prompts • ${enabledPrompts}/${totalPrompts} enabled`,
+        value: () => setScreen({ kind: "config-prompts" }),
+      },
       {
         label: `Todo tool • ${configData.tools.todo.enabled ? "Enabled" : "Disabled"}`,
         value: () => {
@@ -499,6 +516,23 @@ export function ConfigureApp({
           setScreen({ kind: "config" });
         },
       },
+      {
+        label: `Sleep tool • ${configData.tools.sleep.enabled ? "Enabled" : "Disabled"}`,
+        value: () => {
+          updateConfig(
+            {
+              tools: {
+                ...config.tools,
+                sleep: {
+                  enabled: !configData.tools.sleep.enabled,
+                },
+              },
+            },
+            `Sleep tool ${configData.tools.sleep.enabled ? "disabled" : "enabled"}.`,
+          );
+          setScreen({ kind: "config" });
+        },
+      },
       {
         label: `Long-term memory • ${configData.tools.ltm.enabled ? "Enabled" : "Disabled"} • ${configData.tools.ltm.chroma.collection.memory}`,
         value: () => setScreen({ kind: "config-ltm" }),
@@ -636,6 +670,45 @@ export function ConfigureApp({
     );
   };
 
+  const renderPromptsConfigMenu = () => {
+    const promptKeys = Object.keys(
+      PROMPT_LABELS,
+    ) as (keyof ConfigData["prompts"])[];
+    const items: MenuItem[] = [
+      ...promptKeys.map((key) => {
+        const enabled = configData.prompts[key];
+        const label = PROMPT_LABELS[key];
+        return {
+          label: `${label} • ${enabled ? "Enabled" : "Disabled"}`,
+          value: () => {
+            updateConfig(
+              {
+                prompts: {
+                  ...config.prompts,
+                  [key]: !enabled,
+                },
+              },
+              `${label} prompt ${enabled ? "disabled" : "enabled"}.`,
+            );
+            setScreen({ kind: "config-prompts" });
+          },
+        };
+      }),
+      {
+        label: "Back",
+        value: () => setScreen({ kind: "config" }),
+      },
+    ];
+
+    return (
+      <MenuScreen
+        title="Prompts"
+        description="Choose which bundled harness prompt sections are included in future sessions."
+        items={items}
+      />
+    );
+  };
+
   const renderLtmConfigMenu = () => {
     const items: MenuItem[] = [
       {
@@ -1096,6 +1169,8 @@ export function ConfigureApp({
         return renderConfigMenu();
       case "config-provider":
         return renderProviderMenu();
+      case "config-prompts":
+        return renderPromptsConfigMenu();
       case "config-ltm":
         return renderLtmConfigMenu();
       case "config-wiki":

package/src/configure/types.ts

@@ -13,6 +13,7 @@ export type Screen =
   | { kind: "home" }
   | { kind: "config" }
   | { kind: "config-provider" }
+  | { kind: "config-prompts" }
   | { kind: "config-ltm" }
   | { kind: "config-wiki" }
   | { kind: "mcp" }

package/src/core/agent/index.ts

@@ -1,4 +1,5 @@
 import { Agent, BeforeInvocationEvent } from "@strands-agents/sdk";
+import type { Tool } from "@strands-agents/sdk";
 import type { Config } from "../config.ts";
 import { modelProviders } from "../models";
 import {
@@ -14,10 +15,15 @@ import {
   createLongTermMemoryTools,
 } from "../memory";
 import { createSkillsTools, type Registry } from "../skills";
+import {
+  createRunAgentsTools,
+  loadBuiltInAgentDefinitions,
+} from "../agents/index.ts";
 import {
   createTodoTools,
   createFetchTools,
   createFilesystemTools,
+  createSleepTools,
   createShellTools,
   createThinkingTools,
   createTimeTools,
@@ -49,7 +55,7 @@ export async function create(
   const skills = config.tools.skills.enabled
     ? (await createSkillsPrompt(registry)).content
     : "";
-  const tools = config.tools.mcp.enabled
+  const prefixed = config.tools.mcp.enabled
     ? await mcp.manager.listPrefixedTools()
     : [];
   const append = config.tools.mcp.enabled
@@ -58,27 +64,44 @@ export async function create(
   const prompt = [system.content, meta.systemPrompt, ...append, skills]
     .filter((x) => !!x)
     .join(SECTION_BREAK);
+  const model = llm.create(config.llm.model, config.llm.params);
+  const tools: Tool[] = [
+    ...createTimeTools(),
+    ...(config.tools.sleep.enabled ? createSleepTools() : []),
+    ...(config.tools.todo.enabled ? createTodoTools() : []),
+    ...(config.tools.fetch.enabled ? createFetchTools() : []),
+    ...(ltm ? createLongTermMemoryTools(ltm) : []),
+    ...(config.tools.filesystem.enabled ? createFilesystemTools() : []),
+    ...(config.tools.shell.enabled ? createShellTools() : []),
+    ...(config.tools.wiki.enabled ? createWikiTools(config) : []),
+    ...(config.tools.mcp.enabled ? createMcpTools(mcp.config) : []),
+    ...(config.tools.skills.enabled ? createSkillsTools(registry) : []),
+    ...createThinkingTools(),
+    ...prefixed,
+  ];
+  if (config.tools.agents.enabled) {
+    const definitions = loadBuiltInAgentDefinitions(config, {
+      knownTools: tools.map((entry) => entry.name),
+    });
+    tools.push(
+      ...createRunAgentsTools({
+        parent: config.name,
+        definitions,
+        tools,
+        createModel: () => llm.create(config.llm.model, config.llm.params),
+        defaultConcurrency: config.tools.agents.concurrency,
+      }),
+    );
+  }
   const agent = new Agent({
     name: config.name,
     systemPrompt: prompt,
-    model: llm.create(config.llm.model, config.llm.params),
+    model,
     appState: {
       ...(userId ? { userId } : {}),
       ...(sessionId ? { sessionId } : {}),
     },
-    tools: [
-      ...createTimeTools(),
-      ...(config.tools.todo.enabled ? createTodoTools() : []),
-      ...(config.tools.fetch.enabled ? createFetchTools() : []),
-      ...(ltm ? createLongTermMemoryTools(ltm) : []),
-      ...(config.tools.filesystem.enabled ? createFilesystemTools() : []),
-      ...(config.tools.shell.enabled ? createShellTools() : []),
-      ...(config.tools.wiki.enabled ? createWikiTools(config) : []),
-      ...(config.tools.mcp.enabled ? createMcpTools(mcp.config) : []),
-      ...(config.tools.skills.enabled ? createSkillsTools(registry) : []),
-      ...createThinkingTools(),
-      ...tools,
-    ],
+    tools,
     printer: print,
     ...stm,
   });

package/src/core/agents/definitions.ts

@@ -0,0 +1,46 @@
+export const BUILTIN_AGENT_KINDS = ["research", "plan"] as const;
+
+export type AgentKind = (typeof BUILTIN_AGENT_KINDS)[number];
+
+export type AgentConfig = {
+  id: AgentKind;
+  instructions: string;
+  description: string;
+  tools: readonly string[];
+};
+
+export type AgentDefinition = AgentConfig & {
+  instructionsText: string;
+};
+
+export const BUILTIN_AGENT_CONFIGS: readonly AgentConfig[] = [
+  {
+    id: "research",
+    instructions: "research.md",
+    description: "Investigates sources and context before the parent acts.",
+    tools: [
+      "read_file",
+      "read_multiple_files",
+      "list_directory",
+      "directory_tree",
+      "search_files",
+      "get_file_info",
+      "fetch",
+      "think",
+    ],
+  },
+  {
+    id: "plan",
+    instructions: "plan.md",
+    description: "Produces plans, tradeoffs, risks, and validation steps.",
+    tools: [
+      "read_file",
+      "read_multiple_files",
+      "list_directory",
+      "directory_tree",
+      "search_files",
+      "get_file_info",
+      "think",
+    ],
+  },
+];

package/src/core/agents/index.ts

@@ -0,0 +1,15 @@
+export {
+  BUILTIN_AGENT_CONFIGS,
+  BUILTIN_AGENT_KINDS,
+  type AgentConfig,
+  type AgentDefinition,
+  type AgentKind,
+} from "./definitions.ts";
+export { loadBuiltInAgentDefinitions } from "./registry.ts";
+export {
+  runAgentJobs,
+  type AgentJob,
+  type AgentJobResult,
+  type RunAgentJobsResult,
+} from "./runner.ts";
+export { RUN_AGENTS_TOOL_NAME, createRunAgentsTools } from "./tools.ts";

package/src/core/agents/registry.ts

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compile } from "handlebars";
+import type { Config } from "../config.ts";
+import { getEnvironmentPromptContext } from "../prompts/environment.ts";
+import {
+  BUILTIN_AGENT_CONFIGS,
+  type AgentConfig,
+  type AgentDefinition,
+} from "./definitions.ts";
+
+function promptsDir(): string {
+  return join(dirname(fileURLToPath(import.meta.url)), "../prompts/agents");
+}
+
+function validateConfigs(configs: readonly AgentConfig[]): void {
+  const seen = new Set<string>();
+  for (const config of configs) {
+    if (!config.id.trim()) {
+      throw new Error("Agent config id cannot be empty.");
+    }
+    if (seen.has(config.id)) {
+      throw new Error(`Duplicate agent config id: '${config.id}'.`);
+    }
+    seen.add(config.id);
+    if (!config.instructions.trim()) {
+      throw new Error(
+        `Agent '${config.id}' instructions file cannot be empty.`,
+      );
+    }
+    if (!config.description.trim()) {
+      throw new Error(`Agent '${config.id}' description cannot be empty.`);
+    }
+    if (!Array.isArray(config.tools) || config.tools.length === 0) {
+      throw new Error(`Agent '${config.id}' must declare at least one tool.`);
+    }
+    for (const toolName of config.tools) {
+      if (!toolName.trim()) {
+        throw new Error(`Agent '${config.id}' has an empty tool name.`);
+      }
+    }
+  }
+}
+
+function assertKnownTools(
+  definitions: readonly AgentDefinition[],
+  knownTools: readonly string[],
+): void {
+  const known = new Set(knownTools);
+  for (const definition of definitions) {
+    for (const toolName of definition.tools) {
+      if (!known.has(toolName)) {
+        throw new Error(
+          `Agent '${definition.id}' references unknown tool '${toolName}'.`,
+        );
+      }
+    }
+  }
+}
+
+function context(config: Config): Record<string, unknown> {
+  return {
+    name: config.name,
+    llm: config.llm,
+    environment: getEnvironmentPromptContext(),
+    ltm: config.tools.ltm,
+    wiki: config.tools.wiki,
+    compaction: config.compaction,
+  };
+}
+
+export function loadBuiltInAgentDefinitions(
+  config: Config,
+  options?: { knownTools?: readonly string[] },
+): AgentDefinition[] {
+  validateConfigs(BUILTIN_AGENT_CONFIGS);
+  const dir = promptsDir();
+  const definitions = BUILTIN_AGENT_CONFIGS.map((entry) => {
+    const fullPath = join(dir, entry.instructions);
+    if (!existsSync(fullPath)) {
+      throw new Error(
+        `Agent '${entry.id}' instructions file not found: ${entry.instructions}`,
+      );
+    }
+    const raw = readFileSync(fullPath, "utf8").trim();
+    if (!raw) {
+      throw new Error(
+        `Agent '${entry.id}' instructions file is empty: ${entry.instructions}`,
+      );
+    }
+    const template = compile(raw);
+    const instructionsText = template(context(config)).trim();
+    if (!instructionsText) {
+      throw new Error(
+        `Agent '${entry.id}' instructions rendered to empty content.`,
+      );
+    }
+    return {
+      ...entry,
+      instructionsText,
+    };
+  });
+  if (options?.knownTools) {
+    assertKnownTools(definitions, options.knownTools);
+  }
+  return definitions;
+}