@botbotgo/runtime 1.0.0

package/test/unit/runtime/humanLoop.test.ts

@@ -0,0 +1,104 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createAgentEventBus } from "@botbotgo/common/events";
+import { AgentRuntimeEventPublisher } from "../../../src/runtime/events/eventPublisher.ts";
+import { createDefaultHumanLoopToolPolicy } from "../../../src/runtime/human-loop/humanLoop.ts";
+import { AgentToolMiddlewareFactory } from "../../../src/runtime/middleware/agentToolMiddleware.ts";
+
+class FakeToolMessage {
+  public readonly content: string;
+  public readonly tool_call_id: string;
+
+  public constructor(fields: { content: string; tool_call_id: string }) {
+    this.content = fields.content;
+    this.tool_call_id = fields.tool_call_id;
+  }
+}
+
+function createMiddlewareHarness(options: {
+  humanLoopDecision?: {
+    action: "approve" | "reject" | "revise";
+    message?: string;
+    revisedArgs?: Record<string, unknown>;
+  };
+}) {
+  let capturedRequest: unknown;
+  let handlerCalls = 0;
+  let handlerArgs: unknown;
+
+  const middleware = new AgentToolMiddlewareFactory({
+    rootDir: "/workspace",
+    createMiddleware: (definition) => definition,
+    ToolMessage: FakeToolMessage,
+    events: new AgentRuntimeEventPublisher(createAgentEventBus()),
+    humanLoop: options.humanLoopDecision
+      ? {
+        request: async (request) => {
+          capturedRequest = request;
+          return options.humanLoopDecision!;
+        },
+      }
+      : undefined,
+    humanLoopToolPolicy: options.humanLoopDecision
+      ? createDefaultHumanLoopToolPolicy({ toolNames: ["execute"] })
+      : undefined,
+  }).create() as {
+    wrapToolCall: (request: unknown, handler: (request: unknown) => unknown) => Promise<unknown>;
+  };
+
+  return {
+    middleware,
+    getCapturedRequest: () => capturedRequest,
+    getHandlerCalls: () => handlerCalls,
+    getHandlerArgs: () => handlerArgs,
+    run: async () =>
+      middleware.wrapToolCall(
+        {
+          toolCall: {
+            id: "call-1",
+            name: "execute",
+            args: { command: "printf unsafe" },
+          },
+          configurable: { thread_id: "thread-1" },
+        },
+        async (request) => {
+          handlerCalls += 1;
+          handlerArgs = request;
+          return { ok: true, request };
+        },
+      ),
+  };
+}
+
+test("human loop reject prevents tool execution", async () => {
+  const harness = createMiddlewareHarness({
+    humanLoopDecision: {
+      action: "reject",
+      message: "Denied by reviewer.",
+    },
+  });
+
+  const result = await harness.run();
+
+  assert.equal(harness.getHandlerCalls(), 0);
+  assert.equal((result as FakeToolMessage).content, "Denied by reviewer.");
+  assert.match(JSON.stringify(harness.getCapturedRequest()), /"toolName":"execute"/);
+  assert.match(JSON.stringify(harness.getCapturedRequest()), /"threadId":"thread-1"/);
+});
+
+test("human loop revise updates args before tool execution", async () => {
+  const harness = createMiddlewareHarness({
+    humanLoopDecision: {
+      action: "revise",
+      revisedArgs: { command: "printf safe" },
+    },
+  });
+
+  await harness.run();
+
+  assert.equal(harness.getHandlerCalls(), 1);
+  assert.deepEqual(
+    (harness.getHandlerArgs() as { toolCall: { args: unknown } }).toolCall.args,
+    { command: "printf safe" },
+  );
+});

package/test/unit/runtime/toolArgsNormalizer.test.ts

@@ -0,0 +1,136 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { FrameworkPrompt } from "../../../src/runtime/middleware/frameworkPrompt.ts";
+import { ToolArgsNormalizer } from "../../../src/runtime/middleware/toolArgsNormalizer.ts";
+import { buildSkillPathMap } from "../../../src/runtime/middleware/skillPathMap.ts";
+
+test("ToolArgsNormalizer rewrites execute args relative to a unique skill root", async () => {
+  const root = join(tmpdir(), `agent-runtime2-skill-path-${Date.now()}`);
+  const skillRoot = join(root, ".agent", "cache", "skills", "company-report");
+  await mkdir(join(skillRoot, "scripts"), { recursive: true });
+  await mkdir(join(skillRoot, "references"), { recursive: true });
+  await writeFile(join(skillRoot, "scripts", "merge-report.mjs"), "export {};\n", "utf8");
+  await writeFile(join(skillRoot, "references", "company-report.template.html"), "<html></html>\n", "utf8");
+
+  const normalized = ToolArgsNormalizer.normalizeToolArgs(
+    root,
+    [skillRoot],
+    "execute",
+    {
+      command: "node scripts/merge-report.mjs output/company-report.json output/company-report.html references/company-report.template.html",
+    },
+  );
+
+  assert.equal(
+    normalized.command,
+    "node .agent/cache/skills/company-report/scripts/merge-report.mjs output/company-report.json output/company-report.html .agent/cache/skills/company-report/references/company-report.template.html",
+  );
+
+  await rm(root, { recursive: true, force: true });
+});
+
+test("ToolArgsNormalizer expands WORKSPACE and named SKILL_PATH placeholders across multiple skills", async () => {
+  const root = join(tmpdir(), `agent-runtime2-skill-vars-${Date.now()}`);
+  const companyReportRoot = join(root, ".agent", "cache", "skills", "company-report");
+  const otherSkillRoot = join(root, ".agent", "cache", "skills", "other-skill");
+  await mkdir(join(companyReportRoot, "scripts"), { recursive: true });
+  await mkdir(join(companyReportRoot, "references"), { recursive: true });
+  await mkdir(otherSkillRoot, { recursive: true });
+  await writeFile(join(companyReportRoot, "scripts", "merge-report.mjs"), "export {};\n", "utf8");
+  await writeFile(join(companyReportRoot, "references", "company-report.template.html"), "<html></html>\n", "utf8");
+
+  const normalized = ToolArgsNormalizer.normalizeToolArgs(
+    root,
+    [companyReportRoot, otherSkillRoot],
+    "execute",
+    {
+      command:
+        "node ${SKILL_PATH:company-report}/scripts/merge-report.mjs ${WORKSPACE}/output/company-report.json ${WORKSPACE}/output/company-report.html ${SKILL_PATH:company-report}/references/company-report.template.html",
+    },
+  );
+
+  assert.equal(
+    normalized.command,
+    `node ${companyReportRoot.replace(/\\/g, "/")}/scripts/merge-report.mjs ${root.replace(/\\/g, "/")}/output/company-report.json ${root.replace(/\\/g, "/")}/output/company-report.html ${companyReportRoot.replace(/\\/g, "/")}/references/company-report.template.html`,
+  );
+
+  await rm(root, { recursive: true, force: true });
+});
+
+test("FrameworkPrompt includes active skill mapping in framework system prompt", () => {
+  const prompt = FrameworkPrompt.build(
+    undefined,
+    false,
+    ["yahooFinanceQuote"],
+    {
+      "company-report": "/cache/skills/company-report",
+      "other-skill": "/cache/skills/other-skill",
+    },
+  );
+
+  assert.match(prompt, /Active skills for this run:/);
+  assert.match(prompt, /company-report => \/cache\/skills\/company-report/);
+  assert.match(prompt, /other-skill => \/cache\/skills\/other-skill/);
+  assert.match(prompt, /\$\{SKILL_PATH:<skill-id>\}/);
+  assert.match(prompt, /\$\{WORKSPACE\}/);
+});
+
+test("buildSkillPathMap expands skills root directories into named skill paths", async () => {
+  const root = join(tmpdir(), `agent-runtime2-skill-map-${Date.now()}`);
+  const skillsRoot = join(root, ".agent", "cache", "skills");
+  const companyReportRoot = join(skillsRoot, "company-report");
+  await mkdir(companyReportRoot, { recursive: true });
+  await writeFile(join(companyReportRoot, "SKILL.md"), "# company report\n", "utf8");
+
+  const skillPathMap = buildSkillPathMap([skillsRoot]);
+
+  assert.deepEqual(skillPathMap, {
+    "company-report": companyReportRoot.replace(/\\/g, "/"),
+  });
+
+  const normalized = ToolArgsNormalizer.normalizeToolArgs(
+    root,
+    [skillsRoot],
+    "execute",
+    {
+      command:
+        "node ${SKILL_PATH:company-report}/scripts/merge-report.mjs ${WORKSPACE}/output/company-report.json",
+    },
+    skillPathMap,
+  );
+
+  assert.equal(
+    normalized.command,
+    `node ${companyReportRoot.replace(/\\/g, "/")}/scripts/merge-report.mjs ${root.replace(/\\/g, "/")}/output/company-report.json`,
+  );
+
+  await rm(root, { recursive: true, force: true });
+});
+
+test("ToolArgsNormalizer expands unnamed SKILL_PATH to the only active skill directory", async () => {
+  const root = join(tmpdir(), `agent-runtime2-single-skill-${Date.now()}`);
+  const skillsRoot = join(root, ".agent", "cache", "skills");
+  const companyReportRoot = join(skillsRoot, "company-report");
+  await mkdir(companyReportRoot, { recursive: true });
+  await writeFile(join(companyReportRoot, "SKILL.md"), "# company report\n", "utf8");
+
+  const normalized = ToolArgsNormalizer.normalizeToolArgs(
+    root,
+    [companyReportRoot],
+    "read_file",
+    {
+      path: "${SKILL_PATH}/SKILL.md",
+    },
+    buildSkillPathMap([companyReportRoot]),
+  );
+
+  assert.equal(
+    normalized.path,
+    `${companyReportRoot.replace(/\\/g, "/")}/SKILL.md`,
+  );
+
+  await rm(root, { recursive: true, force: true });
+});

package/tsconfig.json

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