orchajs 0.23.2 → 0.23.4

package/dist/amarsia/metadata.js

@@ -31,9 +31,25 @@ export function createAmarsiaProjectMetadata(bundle, projectRoot) {
     };
 }
 function flattenAgents(agents) {
-    const result = [];
+    const rootIds = new Set(Object.values(agents).map((manifest) => manifest.key));
+    const manifests = new Map();
+    const parentIds = new Map();
+    const orderedIds = [];
+    const traversed = new WeakSet();
     const visit = (manifest, parentExternalId) => {
-        result.push(agentMetadata(manifest, parentExternalId));
+        if (!manifests.has(manifest.key)) {
+            manifests.set(manifest.key, manifest);
+            orderedIds.push(manifest.key);
+        }
+        if (parentExternalId) {
+            const parents = parentIds.get(manifest.key) ?? new Set();
+            parents.add(parentExternalId);
+            parentIds.set(manifest.key, parents);
+        }
+        if (traversed.has(manifest)) {
+            return;
+        }
+        traversed.add(manifest);
         for (const subagent of Object.values(manifest.subagents ?? {})) {
             visit(subagent, manifest.key);
         }
@@ -41,7 +57,17 @@ function flattenAgents(agents) {
     for (const manifest of Object.values(agents)) {
         visit(manifest);
     }
-    return result;
+    return orderedIds.map((externalId) => {
+        const manifest = manifests.get(externalId);
+        if (!manifest) {
+            throw new Error(`Missing compiled agent "${externalId}".`);
+        }
+        const parents = parentIds.get(externalId);
+        const parentExternalId = !rootIds.has(externalId) && parents?.size === 1
+            ? parents.values().next().value
+            : undefined;
+        return agentMetadata(manifest, parentExternalId);
+    });
 }
 function agentMetadata(manifest, parentExternalId) {
     return {

package/dist/bin.js

@@ -1,13 +1,122 @@
 #!/usr/bin/env node
-void import("./cli.js").catch((error) => {
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+const TOOLING_PACKAGES = [
+    "@orchajs/playground-ui@^0.2.3",
+    "esbuild@^0.25",
+    "chokidar@^4",
+    "dotenv@^16",
+];
+const BOOTSTRAP_ENV = "ORCHA_TOOLING_BOOTSTRAPPED";
+void run();
+async function run() {
+    try {
+        await import("./cli.js");
+    }
+    catch (error) {
+        if (process.argv[2] === "playground" &&
+            process.env[BOOTSTRAP_ENV] !== "1" &&
+            isMissingToolingError(error)) {
+            await bootstrapPlayground();
+            return;
+        }
+        reportError(error);
+    }
+}
+async function bootstrapPlayground() {
+    const packageManager = detectPackageManager();
+    const installation = installCommand(packageManager);
+    console.log(`[orcha] Installing development-only playground tooling with ${packageManager}...`);
+    const installCode = await runProcess(installation.command, installation.arguments);
+    if (installCode !== 0) {
+        process.exitCode = installCode;
+        return;
+    }
+    const retryCode = await runProcess(process.execPath, [process.argv[1], ...process.argv.slice(2)], {
+        ...process.env,
+        [BOOTSTRAP_ENV]: "1",
+    });
+    process.exitCode = retryCode;
+}
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent?.startsWith("yarn/")) {
+        return "yarn";
+    }
+    if (userAgent?.startsWith("pnpm/")) {
+        return "pnpm";
+    }
+    if (userAgent?.startsWith("bun/")) {
+        return "bun";
+    }
+    if (existsSync(resolve("yarn.lock"))) {
+        return "yarn";
+    }
+    if (existsSync(resolve("pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(resolve("bun.lock")) ||
+        existsSync(resolve("bun.lockb"))) {
+        return "bun";
+    }
+    return "npm";
+}
+function installCommand(packageManager) {
+    switch (packageManager) {
+        case "yarn":
+            return {
+                command: executable("yarn"),
+                arguments: ["add", "--dev", ...TOOLING_PACKAGES],
+            };
+        case "pnpm":
+            return {
+                command: executable("pnpm"),
+                arguments: ["add", "--save-dev", ...TOOLING_PACKAGES],
+            };
+        case "bun":
+            return {
+                command: executable("bun"),
+                arguments: ["add", "--dev", ...TOOLING_PACKAGES],
+            };
+        default:
+            return {
+                command: executable("npm"),
+                arguments: ["install", "--save-dev", ...TOOLING_PACKAGES],
+            };
+    }
+}
+function executable(command) {
+    return process.platform === "win32" ? `${command}.cmd` : command;
+}
+function runProcess(command, arguments_, env = process.env) {
+    return new Promise((resolveProcess, reject) => {
+        const child = spawn(command, arguments_, {
+            cwd: process.cwd(),
+            env,
+            stdio: "inherit",
+        });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            resolveProcess(code ?? 1);
+        });
+    });
+}
+function isMissingToolingError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return ["@orchajs/playground-ui", "esbuild", "chokidar", "dotenv"].some((name) => message.includes(`"${name}"`) || message.includes(`'${name}'`));
+}
+function reportError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    const dependency = ["esbuild", "chokidar", "dotenv"].find((name) => message.includes(`"${name}"`) || message.includes(`'${name}'`));
-    if (dependency) {
-        console.error(`Orcha development tooling requires optional dependencies. Install them with:\n\n  npm install --save-dev esbuild chokidar dotenv`);
+    if (isMissingToolingError(error)) {
+        console.error(`Orcha development tooling is missing. Run "orcha playground" to install the development-only playground dependencies automatically.`);
     }
     else {
         console.error(message);
     }
     process.exitCode = 1;
-});
-export {};
+}

package/dist/playground/server.js

@@ -6,7 +6,6 @@ import { extname, isAbsolute, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createServer, } from "node:http";
 import { watch } from "chokidar";
-import { build } from "esbuild";
 import { orcha } from "../orcha.js";
 import { loadProject } from "../project-loader.js";
 import { listTests, runTests } from "../testing.js";
@@ -475,10 +474,12 @@ async function serveAsset(response, pathname, publicRoot) {
     response.end(await readFile(path));
 }
 async function buildPlaygroundAssets(projectRoot) {
-    let entryPath;
+    let scriptPath;
+    let stylesheetPath;
     let logoPath;
     try {
-        entryPath = fileURLToPath(import.meta.resolve("@orchajs/playground-ui/mount"));
+        scriptPath = fileURLToPath(import.meta.resolve("@orchajs/playground-ui/app.js"));
+        stylesheetPath = fileURLToPath(import.meta.resolve("@orchajs/playground-ui/app.css"));
         logoPath = fileURLToPath(import.meta.resolve("@orchajs/playground-ui/orcha-logo.svg"));
     }
     catch (error) {
@@ -487,20 +488,8 @@ async function buildPlaygroundAssets(projectRoot) {
     const publicRoot = resolve(projectRoot, ".orcha/playground");
     await mkdir(publicRoot, { recursive: true });
     await Promise.all([
-        build({
-            entryPoints: [entryPath],
-            outfile: resolve(publicRoot, "app.js"),
-            bundle: true,
-            format: "esm",
-            platform: "browser",
-            target: ["chrome110", "firefox110", "safari16"],
-            minify: true,
-            sourcemap: false,
-            legalComments: "none",
-            define: {
-                "process.env.NODE_ENV": JSON.stringify("production"),
-            },
-        }),
+        copyFile(scriptPath, resolve(publicRoot, "app.js")),
+        copyFile(stylesheetPath, resolve(publicRoot, "app.css")),
         copyFile(logoPath, resolve(publicRoot, "orcha-logo.svg")),
         writeFile(resolve(publicRoot, "index.html"), `<!doctype html>
 <html lang="en">

package/dist/runtime/agent.js

@@ -628,7 +628,7 @@ export class RuntimeAgent {
                     reasoningLevel: this.#manifest.reasoningLevel,
                     outputType: this.#manifest.outputType,
                     outputSchema: this.#manifest.outputSchema,
-                    systemPrompt: buildSystemPrompt(this.#manifest, previousEvents, variables),
+                    systemPrompt: buildSystemPrompt(this.#manifest, previousEvents, variables, availableToolNames),
                     messages,
                     tools: providerTools,
                     publishOutput: (output) => {
@@ -1895,8 +1895,18 @@ function renderPrompt(template, variables) {
         return variables[name];
     });
 }
-function buildSystemPrompt(manifest, events, variables) {
+function buildSystemPrompt(manifest, events, variables, availableActionNames) {
     const sections = [renderPrompt(manifest.systemPrompt, variables)];
+    if (availableActionNames.length > 0) {
+        sections.push([
+            "## Available actions",
+            "The following actions are available in this run. Invoke the relevant action when the workflow requires it; do not claim it is unavailable.",
+            ...availableActionNames.map((name) => {
+                const action = manifest.actions[name];
+                return `- ${action.name}: ${action.description}`;
+            }),
+        ].join("\n"));
+    }
     const skills = manifest.skills ?? {};
     const availableSkills = Object.values(skills);
     if (availableSkills.length > 0) {

package/dist-cjs/amarsia/metadata.js

@@ -55,9 +55,27 @@ function createAmarsiaProjectMetadata(bundle, projectRoot) {
   };
 }
 function flattenAgents(agents) {
-  const result = [];
+  const rootIds = new Set(
+    Object.values(agents).map((manifest) => manifest.key)
+  );
+  const manifests = /* @__PURE__ */ new Map();
+  const parentIds = /* @__PURE__ */ new Map();
+  const orderedIds = [];
+  const traversed = /* @__PURE__ */ new WeakSet();
   const visit = (manifest, parentExternalId) => {
-    result.push(agentMetadata(manifest, parentExternalId));
+    if (!manifests.has(manifest.key)) {
+      manifests.set(manifest.key, manifest);
+      orderedIds.push(manifest.key);
+    }
+    if (parentExternalId) {
+      const parents = parentIds.get(manifest.key) ?? /* @__PURE__ */ new Set();
+      parents.add(parentExternalId);
+      parentIds.set(manifest.key, parents);
+    }
+    if (traversed.has(manifest)) {
+      return;
+    }
+    traversed.add(manifest);
     for (const subagent of Object.values(manifest.subagents ?? {})) {
       visit(subagent, manifest.key);
     }
@@ -65,7 +83,15 @@ function flattenAgents(agents) {
   for (const manifest of Object.values(agents)) {
     visit(manifest);
   }
-  return result;
+  return orderedIds.map((externalId) => {
+    const manifest = manifests.get(externalId);
+    if (!manifest) {
+      throw new Error(`Missing compiled agent "${externalId}".`);
+    }
+    const parents = parentIds.get(externalId);
+    const parentExternalId = !rootIds.has(externalId) && parents?.size === 1 ? parents.values().next().value : void 0;
+    return agentMetadata(manifest, parentExternalId);
+  });
 }
 function agentMetadata(manifest, parentExternalId) {
   return {

package/dist-cjs/playground/server.js

@@ -30,7 +30,6 @@ var import_path = require("path");
 var import_url = require("url");
 var import_http = require("http");
 var import_chokidar = require("chokidar");
-var import_esbuild = require("esbuild");
 var import_orcha = require("../orcha.js");
 var import_project_loader = require("../project-loader.js");
 var import_testing = require("../testing.js");
@@ -502,11 +501,15 @@ async function serveAsset(response, pathname, publicRoot) {
   response.end(await (0, import_promises.readFile)(path));
 }
 async function buildPlaygroundAssets(projectRoot) {
-  let entryPath;
+  let scriptPath;
+  let stylesheetPath;
   let logoPath;
   try {
-    entryPath = (0, import_url.fileURLToPath)(
-      import_meta.resolve("@orchajs/playground-ui/mount")
+    scriptPath = (0, import_url.fileURLToPath)(
+      import_meta.resolve("@orchajs/playground-ui/app.js")
+    );
+    stylesheetPath = (0, import_url.fileURLToPath)(
+      import_meta.resolve("@orchajs/playground-ui/app.css")
     );
     logoPath = (0, import_url.fileURLToPath)(
       import_meta.resolve("@orchajs/playground-ui/orcha-logo.svg")
@@ -520,20 +523,8 @@ async function buildPlaygroundAssets(projectRoot) {
   const publicRoot = (0, import_path.resolve)(projectRoot, ".orcha/playground");
   await (0, import_promises.mkdir)(publicRoot, { recursive: true });
   await Promise.all([
-    (0, import_esbuild.build)({
-      entryPoints: [entryPath],
-      outfile: (0, import_path.resolve)(publicRoot, "app.js"),
-      bundle: true,
-      format: "esm",
-      platform: "browser",
-      target: ["chrome110", "firefox110", "safari16"],
-      minify: true,
-      sourcemap: false,
-      legalComments: "none",
-      define: {
-        "process.env.NODE_ENV": JSON.stringify("production")
-      }
-    }),
+    (0, import_promises.copyFile)(scriptPath, (0, import_path.resolve)(publicRoot, "app.js")),
+    (0, import_promises.copyFile)(stylesheetPath, (0, import_path.resolve)(publicRoot, "app.css")),
     (0, import_promises.copyFile)(logoPath, (0, import_path.resolve)(publicRoot, "orcha-logo.svg")),
     (0, import_promises.writeFile)(
       (0, import_path.resolve)(publicRoot, "index.html"),

package/dist-cjs/runtime/agent.js

@@ -826,7 +826,8 @@ class RuntimeAgent {
             systemPrompt: buildSystemPrompt(
               this.#manifest,
               previousEvents,
-              variables
+              variables,
+              availableToolNames
             ),
             messages,
             tools: providerTools,
@@ -2197,8 +2198,20 @@ function renderPrompt(template, variables) {
     }
   );
 }
-function buildSystemPrompt(manifest, events, variables) {
+function buildSystemPrompt(manifest, events, variables, availableActionNames) {
   const sections = [renderPrompt(manifest.systemPrompt, variables)];
+  if (availableActionNames.length > 0) {
+    sections.push(
+      [
+        "## Available actions",
+        "The following actions are available in this run. Invoke the relevant action when the workflow requires it; do not claim it is unavailable.",
+        ...availableActionNames.map((name) => {
+          const action = manifest.actions[name];
+          return `- ${action.name}: ${action.description}`;
+        })
+      ].join("\n")
+    );
+  }
   const skills = manifest.skills ?? {};
   const availableSkills = Object.values(skills);
   if (availableSkills.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchajs",
-  "version": "0.23.2",
+  "version": "0.23.4",
   "description": "A filesystem-convention, stateful agent framework for JavaScript.",
   "license": "MIT",
   "repository": {
@@ -124,7 +124,7 @@
     "node": ">=18.20.8"
   },
   "peerDependencies": {
-    "@orchajs/playground-ui": ">=0.2.3",
+    "@orchajs/playground-ui": ">=0.2.4",
     "@react-native-async-storage/async-storage": ">=2 <3",
     "@aws-sdk/client-bedrock-runtime": ">=3.864.0 <4",
     "@google/genai": ">=2.22.0 <3",