@lumerahq/cli 0.12.0 → 0.13.1

package/dist/{chunk-UGFGRGNP.js → chunk-7ZGIC6F7.js}

@@ -146,6 +146,42 @@ var ApiClient = class {
       method: "DELETE"
     });
   }
+  // Agents
+  async listAgents() {
+    const result = await this.request("/api/agents?limit=100");
+    return result.agents || [];
+  }
+  async createAgent(def) {
+    return this.request("/api/agents", {
+      method: "POST",
+      body: JSON.stringify(def)
+    });
+  }
+  async updateAgent(id, def) {
+    return this.request(`/api/agents/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(def)
+    });
+  }
+  async deleteAgent(id) {
+    await this.request(`/api/agents/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Agent Skills (for slug-to-ID resolution)
+  async listAgentSkills() {
+    const result = await this.request("/api/lm_agent_skills?limit=100");
+    return result.skills || [];
+  }
+  // Agent Invoke
+  async invokeAgent(agentId, message, sessionId) {
+    const body = { message };
+    if (sessionId) body.session_id = sessionId;
+    return this.request(`/api/agents/${agentId}/invoke`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
 };
 function createApiClient(token, baseUrl) {
   return new ApiClient(token, baseUrl);

package/dist/{dev-IFEYXWVJ.js → dev-LNH47WSS.js}

@@ -4,7 +4,7 @@ import {
 import {
   createApiClient,
   loadEnv
-} from "./chunk-UGFGRGNP.js";
+} from "./chunk-7ZGIC6F7.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";

package/dist/index.js

@@ -139,7 +139,7 @@ ${pc.dim("Resource Commands:")}
 
 ${pc.dim("Development:")}
   ${pc.cyan("dev")}                      Start dev server
-  ${pc.cyan("run")} <target>             Run script or trigger automation
+  ${pc.cyan("run")} <target>             Run script, trigger automation, or invoke agent
 
 ${pc.dim("Project:")}
   ${pc.cyan("init")} [name]              Scaffold a new project
@@ -167,6 +167,7 @@ ${pc.dim("Resource Types:")}
   collections              Data collections (schemas)
   automations              Background Python scripts
   hooks                    Collection lifecycle handlers
+  agents                   AI agents with skills and prompts
   app                      Frontend application
 
 ${pc.dim("Examples:")}
@@ -177,6 +178,7 @@ ${pc.dim("Examples:")}
   lumera show collections/users       # Show collection details
   lumera run scripts/seed.py          # Run a script
   lumera run automations/sync         # Trigger automation
+  lumera run agents/support "Hello"   # Invoke an agent
   lumera dev                          # Start dev server
 
 ${pc.dim("Documentation:")}
@@ -208,29 +210,29 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-4AP5AXH5.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-PKLA2XDG.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-4AP5AXH5.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-PKLA2XDG.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-4AP5AXH5.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-PKLA2XDG.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-4AP5AXH5.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-PKLA2XDG.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-4AP5AXH5.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-PKLA2XDG.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-4AP5AXH5.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-PKLA2XDG.js").then((m) => m.show(args.slice(1)));
         break;
       // Development
       case "dev":
-        await import("./dev-IFEYXWVJ.js").then((m) => m.dev(args.slice(1)));
+        await import("./dev-LNH47WSS.js").then((m) => m.dev(args.slice(1)));
         break;
       case "run":
-        await import("./run-PBM4WOJT.js").then((m) => m.run(args.slice(1)));
+        await import("./run-3UBV3SVA.js").then((m) => m.run(args.slice(1)));
         break;
       // Project
       case "init":

package/dist/{resources-4AP5AXH5.js → resources-PKLA2XDG.js}

@@ -4,7 +4,7 @@ import {
 import {
   createApiClient,
   loadEnv
-} from "./chunk-UGFGRGNP.js";
+} from "./chunk-7ZGIC6F7.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";
@@ -18,8 +18,19 @@ import {
 // src/commands/resources.ts
 import pc from "picocolors";
 import prompts from "prompts";
+import { execFileSync, execSync } from "child_process";
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join, resolve } from "path";
+function detectPackageManager() {
+  for (const pm of ["bun", "pnpm", "yarn", "npm"]) {
+    try {
+      execFileSync(pm, ["--version"], { stdio: "ignore" });
+      return pm;
+    } catch {
+    }
+  }
+  return "npm";
+}
 function showPlanHelp() {
   console.log(`
 ${pc.dim("Usage:")}
@@ -35,6 +46,8 @@ ${pc.dim("Resources:")}
   automations         Plan only automations
   automations/<name>  Plan single automation
   hooks               Plan only hooks
+  agents              Plan only agents
+  agents/<name>       Plan single agent
   app                 Plan app deployment
 
 ${pc.dim("Examples:")}
@@ -58,6 +71,8 @@ ${pc.dim("Resources:")}
   automations         Apply only automations
   automations/<name>  Apply single automation
   hooks               Apply only hooks
+  agents              Apply only agents
+  agents/<name>       Apply single agent
   app                 Deploy the frontend app
 
 ${pc.dim("Options:")}
@@ -86,6 +101,8 @@ ${pc.dim("Resources:")}
   automations         Pull only automations
   automations/<name>  Pull single automation
   hooks               Pull only hooks
+  agents              Pull only agents
+  agents/<name>       Pull single agent
 
 ${pc.dim("Examples:")}
   lumera pull                        # Pull all resources
@@ -108,6 +125,8 @@ ${pc.dim("Resources:")}
   automations         Destroy only automations
   automations/<name>  Destroy single automation
   hooks               Destroy only hooks
+  agents              Destroy only agents
+  agents/<name>       Destroy single agent
   app                 Delete app registration
 
 ${pc.dim("Options:")}
@@ -133,6 +152,7 @@ ${pc.dim("Types:")}
   collections         List only collections
   automations         List only automations
   hooks               List only hooks
+  agents              List only agents
 
 ${pc.dim("Options:")}
   --all               Include remote-only resources
@@ -155,6 +175,7 @@ ${pc.dim("Resources:")}
   collections/<name>  Show collection details
   automations/<name>  Show automation details
   hooks/<name>        Show hook details
+  agents/<name>       Show agent details
   app                 Show app details
 
 ${pc.dim("Examples:")}
@@ -170,7 +191,7 @@ function parseResource(resourcePath) {
   const parts = resourcePath.split("/");
   const type = parts[0];
   const name = parts.slice(1).join("/") || null;
-  if (!["collections", "automations", "hooks", "app"].includes(type)) {
+  if (!["collections", "automations", "hooks", "agents", "app"].includes(type)) {
     return { type: null, name: null };
   }
   return { type, name };
@@ -701,9 +722,9 @@ async function applyApp(args) {
   const apiUrl = getApiUrl();
   if (!skipBuild) {
     console.log(pc.dim("  Building..."));
-    const { execSync } = await import("child_process");
     try {
-      execSync("pnpm build", { cwd: projectRoot, stdio: "inherit" });
+      const pm = detectPackageManager();
+      execSync(`${pm} run build`, { cwd: projectRoot, stdio: "inherit" });
     } catch {
       throw new Error("Build failed");
     }
@@ -823,6 +844,165 @@ ${hook.script.split("\n").map((line) => "  " + line).join("\n")}
     console.log(pc.green("  \u2713"), `${hook.name} \u2192 hooks/${fileName}`);
   }
 }
+function loadLocalAgents(platformDir, filterName, appName) {
+  const agentsDir = join(platformDir, "agents");
+  if (!existsSync(agentsDir)) return [];
+  const agents = [];
+  const errors = [];
+  for (const entry of readdirSync(agentsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const agentDir = join(agentsDir, entry.name);
+    const configPath = join(agentDir, "config.json");
+    const promptPath = join(agentDir, "system_prompt.md");
+    if (!existsSync(configPath)) {
+      errors.push(`${entry.name}: missing config.json`);
+      continue;
+    }
+    if (!existsSync(promptPath)) {
+      errors.push(`${entry.name}: missing system_prompt.md`);
+      continue;
+    }
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (filterName && config.external_id !== filterName && config.name !== filterName && entry.name !== filterName) {
+        continue;
+      }
+      if (!config.external_id) {
+        if (appName) {
+          config.external_id = `${appName}:${entry.name}`;
+        } else {
+          errors.push(`${entry.name}: missing external_id in config.json`);
+          continue;
+        }
+      }
+      if (!config.name) {
+        errors.push(`${entry.name}: missing name in config.json`);
+        continue;
+      }
+      const systemPrompt = readFileSync(promptPath, "utf-8");
+      agents.push({ agent: config, systemPrompt });
+    } catch (e) {
+      errors.push(`${entry.name}: failed to parse config.json - ${e}`);
+    }
+  }
+  if (errors.length > 0) {
+    console.log(pc.red("  Agent errors:"));
+    for (const err of errors) {
+      console.log(pc.red(`    \u2717 ${err}`));
+    }
+    throw new Error(`Found ${errors.length} agent error(s)`);
+  }
+  return agents;
+}
+async function planAgents(api, localAgents) {
+  const changes = [];
+  const remoteAgents = await api.listAgents();
+  const remoteByExternalId = new Map(
+    remoteAgents.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a])
+  );
+  for (const { agent, systemPrompt } of localAgents) {
+    const remote = remoteByExternalId.get(agent.external_id);
+    if (!remote) {
+      changes.push({ type: "create", resource: "agent", id: agent.external_id, name: agent.name });
+    } else {
+      const diffs = [];
+      if (remote.name !== agent.name) diffs.push("name");
+      if ((remote.description || "") !== (agent.description || "")) diffs.push("description");
+      if ((remote.system_prompt || "").trim() !== systemPrompt.trim()) diffs.push("system_prompt");
+      if (diffs.length > 0) {
+        changes.push({ type: "update", resource: "agent", id: agent.external_id, name: agent.name, details: `changed: ${diffs.join(", ")}` });
+      }
+    }
+  }
+  return changes;
+}
+async function applyAgents(api, localAgents) {
+  let errors = 0;
+  const remoteAgents = await api.listAgents();
+  const remoteByExternalId = new Map(
+    remoteAgents.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a])
+  );
+  let skillMap = /* @__PURE__ */ new Map();
+  const hasSkillRefs = localAgents.some((a) => a.agent.skills && a.agent.skills.length > 0);
+  if (hasSkillRefs) {
+    try {
+      const skills = await api.listAgentSkills();
+      skillMap = new Map(skills.map((s) => [s.slug, s.id]));
+    } catch (e) {
+      console.log(pc.yellow(`    \u26A0 Could not fetch skills for resolution: ${e}`));
+    }
+  }
+  for (const { agent, systemPrompt } of localAgents) {
+    const remote = remoteByExternalId.get(agent.external_id);
+    const skillIds = [];
+    if (agent.skills) {
+      for (const slug of agent.skills) {
+        const id = skillMap.get(slug);
+        if (id) {
+          skillIds.push(id);
+        } else {
+          console.log(pc.yellow(`    \u26A0 Skill "${slug}" not found, skipping`));
+        }
+      }
+    }
+    const payload = {
+      external_id: agent.external_id,
+      name: agent.name,
+      description: agent.description || "",
+      system_prompt: systemPrompt,
+      skill_ids: skillIds
+    };
+    try {
+      if (remote) {
+        await api.updateAgent(remote.id, payload);
+        console.log(pc.green("  \u2713"), `${agent.name} (updated)`);
+      } else {
+        await api.createAgent(payload);
+        console.log(pc.green("  \u2713"), `${agent.name} (created)`);
+      }
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `${agent.name}: ${e}`);
+      errors++;
+    }
+  }
+  return errors;
+}
+async function pullAgents(api, platformDir, filterName) {
+  const agentsDir = join(platformDir, "agents");
+  mkdirSync(agentsDir, { recursive: true });
+  const agents = await api.listAgents();
+  let skillIdToSlug = /* @__PURE__ */ new Map();
+  try {
+    const skills = await api.listAgentSkills();
+    skillIdToSlug = new Map(skills.map((s) => [s.id, s.slug]));
+  } catch {
+  }
+  for (const agent of agents) {
+    if (!agent.external_id || agent.managed) continue;
+    if (filterName && agent.external_id !== filterName && agent.name !== filterName) {
+      continue;
+    }
+    const dirName = agent.external_id.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const agentDir = join(agentsDir, dirName);
+    mkdirSync(agentDir, { recursive: true });
+    const skillSlugs = [];
+    if (agent.skill_ids) {
+      for (const id of agent.skill_ids) {
+        const slug = skillIdToSlug.get(id);
+        if (slug) skillSlugs.push(slug);
+      }
+    }
+    const config = {
+      external_id: agent.external_id,
+      name: agent.name
+    };
+    if (agent.description) config.description = agent.description;
+    if (skillSlugs.length > 0) config.skills = skillSlugs;
+    writeFileSync(join(agentDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+    writeFileSync(join(agentDir, "system_prompt.md"), agent.system_prompt || "");
+    console.log(pc.green("  \u2713"), `${agent.name} \u2192 agents/${dirName}/`);
+  }
+}
 async function listResources(api, platformDir, filterType, appName) {
   const results = [];
   if (!filterType || filterType === "collections") {
@@ -907,6 +1087,32 @@ async function listResources(api, platformDir, filterType, appName) {
       }
     }
   }
+  if (!filterType || filterType === "agents") {
+    const localAgents = loadLocalAgents(platformDir, void 0, appName);
+    const remoteAgents = await api.listAgents();
+    const remoteByExternalId = new Map(remoteAgents.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a]));
+    const localIds = new Set(localAgents.map((a) => a.agent.external_id));
+    for (const { agent, systemPrompt } of localAgents) {
+      const remote = remoteByExternalId.get(agent.external_id);
+      if (!remote) {
+        results.push({ name: agent.name, type: "agents", status: "local-only" });
+      } else {
+        const promptChanged = (remote.system_prompt || "").trim() !== systemPrompt.trim();
+        const nameChanged = remote.name !== agent.name;
+        if (promptChanged || nameChanged) {
+          results.push({ name: agent.name, type: "agents", status: "changed", details: promptChanged ? "system_prompt" : "name" });
+        } else {
+          results.push({ name: agent.name, type: "agents", status: "synced" });
+        }
+      }
+    }
+    for (const remote of remoteAgents) {
+      if (!remote.external_id || remote.managed) continue;
+      if (!localIds.has(remote.external_id)) {
+        results.push({ name: remote.name, type: "agents", status: "remote-only" });
+      }
+    }
+  }
   return results;
 }
 function planCollectionDelete(collections, platformDir) {
@@ -1016,6 +1222,20 @@ async function destroyResources(api, platformDir, resourceType, resourceName, sk
       }
     }
   }
+  if (!resourceType || resourceType === "agents") {
+    try {
+      const localAgents = loadLocalAgents(platformDir, resourceName || void 0, appName);
+      const remoteAgents = await api.listAgents();
+      const remoteByExternalId = new Map(remoteAgents.filter((a) => a.external_id).map((a) => [a.external_id, a]));
+      for (const { agent } of localAgents) {
+        const remote = remoteByExternalId.get(agent.external_id);
+        if (remote) {
+          toDelete.push({ type: "agent", id: agent.external_id, name: agent.name, remoteId: remote.id });
+        }
+      }
+    } catch {
+    }
+  }
   if (toDelete.length === 0) {
     console.log(pc.green("  \u2713 No resources found to delete"));
     return;
@@ -1038,10 +1258,20 @@ async function destroyResources(api, platformDir, resourceType, resourceName, sk
       return;
     }
   }
+  const agents = toDelete.filter((r) => r.type === "agent");
   const hooks = toDelete.filter((r) => r.type === "hook");
   const automations = toDelete.filter((r) => r.type === "automation");
   const collections = toDelete.filter((r) => r.type === "collection");
   let errors = 0;
+  for (const resource of agents) {
+    try {
+      await api.deleteAgent(resource.remoteId);
+      console.log(pc.green("  \u2713"), `Deleted agent: ${resource.name}`);
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `Failed to delete agent ${resource.name}: ${e}`);
+      errors++;
+    }
+  }
   for (const resource of hooks) {
     try {
       await api.deleteHook(resource.remoteId);
@@ -1250,6 +1480,43 @@ async function showResource(api, platformDir, resourceType, resourceName, appNam
     console.log(`  Trigger: ${local?.hook.trigger || remote?.event}`);
     console.log(`  Enabled: ${local?.hook.enabled !== false || remote?.enabled}`);
     console.log();
+  } else if (resourceType === "agents") {
+    const localAgents = loadLocalAgents(platformDir, resourceName, appName);
+    const remoteAgents = await api.listAgents();
+    const local = localAgents[0];
+    const remote = remoteAgents.find((a) => a.external_id === resourceName || a.name === resourceName);
+    if (!local && !remote) {
+      console.log(pc.red(`  Agent "${resourceName}" not found`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc.bold(`  Agent: ${local?.agent.name || remote?.name}`));
+    console.log();
+    if (local && remote) {
+      const promptChanged = (remote.system_prompt || "").trim() !== local.systemPrompt.trim();
+      const nameChanged = remote.name !== local.agent.name;
+      const descChanged = (remote.description || "") !== (local.agent.description || "");
+      if (promptChanged || nameChanged || descChanged) {
+        console.log(`  Status: ${pc.yellow("changed")}`);
+      } else {
+        console.log(`  Status: ${pc.green("synced")}`);
+      }
+    } else if (local) {
+      console.log(`  Status: ${pc.yellow("local only")}`);
+    } else {
+      console.log(`  Status: ${pc.cyan("remote only")}`);
+    }
+    if (local?.agent.external_id || remote?.external_id) {
+      console.log(`  External ID: ${local?.agent.external_id || remote?.external_id}`);
+    }
+    if (local?.agent.description || remote?.description) {
+      console.log(`  Description: ${local?.agent.description || remote?.description}`);
+    }
+    if (local?.agent.skills?.length || remote?.skill_ids?.length) {
+      const skills = local?.agent.skills || remote?.skill_ids || [];
+      console.log(`  Skills: ${skills.join(", ")}`);
+    }
+    console.log();
   } else if (resourceType === "app") {
     const projectRoot = findProjectRoot();
     loadEnv(projectRoot);
@@ -1325,6 +1592,13 @@ async function plan(args) {
       allChanges.push(...changes);
     }
   }
+  if (!type || type === "agents") {
+    const localAgents = loadLocalAgents(platformDir, name || void 0, appName);
+    if (localAgents.length > 0) {
+      const changes = await planAgents(api, localAgents);
+      allChanges.push(...changes);
+    }
+  }
   if (allChanges.length === 0) {
     console.log(pc.green("  \u2713 No changes detected"));
     console.log();
@@ -1416,6 +1690,17 @@ async function apply(args) {
       process.exit(1);
     }
   }
+  if (!type || type === "agents") {
+    const localAgents = loadLocalAgents(platformDir, name || void 0, appName);
+    if (localAgents.length > 0) {
+      console.log(pc.bold("  Agents:"));
+      totalErrors += await applyAgents(api, localAgents);
+      console.log();
+    } else if (name) {
+      console.log(pc.red(`  Agent "${name}" not found locally`));
+      process.exit(1);
+    }
+  }
   if (!type) {
     try {
       const projectRoot2 = findProjectRoot();
@@ -1463,6 +1748,11 @@ async function pull(args) {
     await pullHooks(api, platformDir, name || void 0);
     console.log();
   }
+  if (!type || type === "agents") {
+    console.log(pc.bold("  Agents:"));
+    await pullAgents(api, platformDir, name || void 0);
+    console.log();
+  }
   console.log(pc.green("  Done!"));
   console.log();
 }

package/dist/{run-PBM4WOJT.js → run-3UBV3SVA.js}

@@ -1,7 +1,7 @@
 import {
   createApiClient,
   loadEnv
-} from "./chunk-UGFGRGNP.js";
+} from "./chunk-7ZGIC6F7.js";
 import {
   getToken
 } from "./chunk-NDLYGKS6.js";
@@ -21,16 +21,18 @@ ${pc.dim("Usage:")}
   lumera run <target> [options]
 
 ${pc.dim("Description:")}
-  Run a script locally or trigger an automation on the platform.
+  Run a script locally, trigger an automation, or invoke an agent.
 
 ${pc.dim("Targets:")}
   scripts/<name>.py      Run a Python script locally using uv
   automations/<name>     Trigger an automation run on the platform
+  agents/<name> "msg"    Invoke an agent on the platform
 
 ${pc.dim("Options:")}
   --local                Run automation code locally instead of on platform
   --preset <name>        Use a specific preset when triggering automation
   --input <json>         Pass JSON input to the automation
+  --session <id>         Use a specific session for agent invocation
   --help, -h             Show this help
 
 ${pc.dim("Examples:")}
@@ -38,6 +40,7 @@ ${pc.dim("Examples:")}
   lumera run automations/sync               # Trigger automation on platform
   lumera run automations/sync --preset daily
   lumera run automations/sync --local       # Run automation code locally
+  lumera run agents/support "Hello"         # Invoke an agent
 
 ${pc.dim("Notes:")}
   - Scripts can declare dependencies using PEP 723 inline metadata
@@ -48,6 +51,7 @@ ${pc.dim("Notes:")}
 function parseFlags(args) {
   const flags = {};
   let target = "";
+  const positionalArgs = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg.startsWith("--")) {
@@ -61,9 +65,11 @@ function parseFlags(args) {
       }
     } else if (!target) {
       target = arg;
+    } else {
+      positionalArgs.push(arg);
     }
   }
-  return { target, flags };
+  return { target, flags, positionalArgs };
 }
 async function runScript(scriptPath, projectRoot) {
   const fullScriptPath = resolve(projectRoot, scriptPath);
@@ -226,12 +232,65 @@ async function runAutomationLocally(automationName, projectRoot, flags) {
   process.on("SIGINT", () => uv.kill("SIGINT"));
   process.on("SIGTERM", () => uv.kill("SIGTERM"));
 }
+async function invokeAgent(agentName, message, flags) {
+  if (!message) {
+    console.error(pc.red("  Message is required."));
+    console.error(pc.dim('  Usage: lumera run agents/<name> "Your message here"'));
+    process.exit(1);
+  }
+  const api = createApiClient();
+  console.log();
+  console.log(pc.cyan(pc.bold("  Invoke Agent")));
+  console.log();
+  const agents = await api.listAgents();
+  const agent = agents.find(
+    (a) => a.external_id === agentName || a.name === agentName
+  );
+  if (!agent) {
+    console.error(pc.red(`  Agent "${agentName}" not found on platform.`));
+    console.error(pc.dim("  Run `lumera list agents` to see available agents."));
+    process.exit(1);
+  }
+  console.log(pc.dim(`  Agent: ${agent.name}`));
+  const sessionId = flags.session ? String(flags.session) : void 0;
+  if (sessionId) {
+    console.log(pc.dim(`  Session: ${sessionId}`));
+  }
+  console.log();
+  try {
+    const result = await api.invokeAgent(
+      agent.external_id || agent.id,
+      message,
+      sessionId
+    );
+    if (result.success) {
+      console.log(result.output);
+    } else {
+      console.error(pc.red(`  Agent error: ${result.error}`));
+      process.exit(1);
+    }
+    if (result.tool_calls && result.tool_calls.length > 0) {
+      console.log();
+      console.log(pc.dim(`  Tool calls: ${result.tool_calls.length}`));
+      for (const tc of result.tool_calls) {
+        console.log(pc.dim(`    - ${tc.tool} (${tc.success ? "ok" : "failed"})`));
+      }
+    }
+    if (result.session_id) {
+      console.log(pc.dim(`  Session: ${result.session_id}`));
+    }
+  } catch (e) {
+    console.error(pc.red(`  Failed to invoke agent: ${e}`));
+    process.exit(1);
+  }
+  console.log();
+}
 async function run(args) {
   if (args.includes("--help") || args.includes("-h") || args.length === 0) {
     showHelp();
     process.exit(args.length === 0 ? 1 : 0);
   }
-  const { target, flags } = parseFlags(args);
+  const { target, flags, positionalArgs } = parseFlags(args);
   let projectRoot;
   try {
     projectRoot = findProjectRoot();
@@ -248,6 +307,12 @@ async function run(args) {
     }
     return;
   }
+  if (target.startsWith("agents/")) {
+    const agentName = target.replace("agents/", "");
+    const message = positionalArgs.join(" ") || void 0;
+    await invokeAgent(agentName, message, flags);
+    return;
+  }
   await runScript(target, projectRoot);
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {