apteva 0.4.11 → 0.4.14

package/src/routes/api/meta-agent.ts

@@ -47,23 +47,31 @@ export async function handleMetaAgentRoutes(
         name: "Apteva Assistant",
         model: defaultModel,
         provider: providerId,
-        system_prompt: `You are the Apteva Assistant, an AI that manages the Apteva agent platform.
-
-You have tools to control the platform directly:
-- Create, configure, start, and stop AI agents
-- Manage projects and organize agents into them
-- View system status, configured providers, and MCP servers
-- Send messages to other running agents
-
-Use your tools proactively when users ask you to do things. For example:
-- "Create a GPT agent" → use create_agent with provider "openai" and model "gpt-4o"
-- "Start my agent" → use start_agent
-- "How many agents do I have?" → use get_dashboard_stats or list_agents
-
-Available providers: anthropic (Claude), openai (GPT), groq (Llama), gemini (Gemini), xai (Grok), together, fireworks, ollama (local).
-Use list_providers to see which have API keys configured.
-
-Be concise and action-oriented. Confirm what you did after taking actions. Use markdown formatting.`,
+        system_prompt: `You are the Apteva Assistant, an AI that manages the Apteva agent platform. You have full control over the platform via your tools.
+
+WHAT YOU CAN DO:
+- **Agents**: Create, configure, start, stop, and delete AI agents
+- **Projects**: Create projects and organize agents into them
+- **MCP Servers**: Add tool integrations (HTTP, npm, pip) and assign them to agents
+- **Skills**: List, enable/disable, and assign skills to agents
+- **Providers**: Check which LLM providers have API keys configured
+- **Communication**: Send messages to running agents
+
+WORKFLOW FOR CREATING AGENTS:
+1. Use list_providers to check which providers have API keys
+2. Use create_agent with a provider that has a key, pick a model, write a good system prompt
+3. Optionally assign MCP servers (for tools) and skills (for behavior)
+4. Use start_agent to run it
+
+AGENT FEATURES (enable when creating/updating):
+- **memory**: Persistent memory across conversations (needs OpenAI key for embeddings)
+- **tasks**: Scheduling and task tracking
+- **vision**: Image and PDF understanding
+- **mcp**: Required if assigning MCP servers — gives the agent tool-use capability
+- **files**: File read/write in agent workspace
+
+ALWAYS use your tools proactively. When a user says "create an agent", don't explain how — just do it. Confirm what you did after.
+Be concise. Use markdown formatting.`,
         features: {
           memory: false,
           tasks: false,

package/src/routes/api/system.ts

@@ -126,8 +126,17 @@ export async function handleSystemRoutes(
   if (path === "/api/tasks" && method === "GET") {
     const url = new URL(req.url);
     const status = url.searchParams.get("status") || "all";
+    const projectId = url.searchParams.get("project_id");
+
+    let runningAgents = AgentDB.findAll().filter(a => a.status === "running" && a.port);
+
+    // Filter agents by project if requested
+    if (projectId === "unassigned") {
+      runningAgents = runningAgents.filter(a => !a.project_id);
+    } else if (projectId) {
+      runningAgents = runningAgents.filter(a => a.project_id === projectId);
+    }
 
-    const runningAgents = AgentDB.findAll().filter(a => a.status === "running" && a.port);
     const allTasks: any[] = [];
 
     for (const agent of runningAgents) {

package/src/routes/api/tests.ts

@@ -0,0 +1,148 @@
+import { json } from "./helpers";
+import { TestCaseDB, TestRunDB } from "../../db-tests";
+import { AgentDB } from "../../db";
+import { runTest, runAll } from "../../test-runner";
+
+export async function handleTestRoutes(
+  req: Request,
+  path: string,
+  method: string,
+): Promise<Response | null> {
+  // GET /api/tests - List test cases
+  if (path === "/api/tests" && method === "GET") {
+    const url = new URL(req.url);
+    const projectId = url.searchParams.get("project_id") || undefined;
+    const tests = TestCaseDB.findAll(projectId);
+
+    // Enrich with agent name and latest run
+    const enriched = tests.map(tc => {
+      const agent = tc.agent_id ? AgentDB.findById(tc.agent_id) : null;
+      const lastRun = TestRunDB.getLatestByTestCase(tc.id);
+      return {
+        ...tc,
+        agent_name: agent?.name || null,
+        agent_status: agent?.status || null,
+        last_run: lastRun ? {
+          id: lastRun.id,
+          status: lastRun.status,
+          score: lastRun.score,
+          duration_ms: lastRun.duration_ms,
+          judge_reasoning: lastRun.judge_reasoning,
+          generated_message: lastRun.generated_message,
+          selected_agent_id: lastRun.selected_agent_id,
+          selected_agent_name: lastRun.selected_agent_name,
+          planner_reasoning: lastRun.planner_reasoning,
+          created_at: lastRun.created_at,
+        } : null,
+      };
+    });
+
+    return json(enriched);
+  }
+
+  // POST /api/tests - Create test case
+  if (path === "/api/tests" && method === "POST") {
+    const body = await req.json() as any;
+
+    // Behavior-driven: only name + behavior required
+    // Legacy: name + agent_id + input_message + eval_criteria required
+    if (!body.name) {
+      return json({ error: "Missing required field: name" }, 400);
+    }
+
+    if (!body.behavior && (!body.agent_id || !body.input_message)) {
+      return json({ error: "Either 'behavior' or both 'agent_id' and 'input_message' are required" }, 400);
+    }
+
+    // Validate agent if explicitly specified
+    if (body.agent_id) {
+      const agent = AgentDB.findById(body.agent_id);
+      if (!agent) {
+        return json({ error: "Agent not found" }, 404);
+      }
+    }
+
+    const testCase = TestCaseDB.create({
+      name: body.name,
+      description: body.description,
+      behavior: body.behavior,
+      agent_id: body.agent_id || null,
+      input_message: body.input_message || null,
+      eval_criteria: body.eval_criteria,
+      project_id: body.project_id,
+    });
+
+    return json(testCase, 201);
+  }
+
+  // PUT /api/tests/:id - Update test case
+  const updateMatch = path.match(/^\/api\/tests\/([^/]+)$/);
+  if (updateMatch && method === "PUT") {
+    const body = await req.json() as any;
+    const updated = TestCaseDB.update(updateMatch[1], body);
+    if (!updated) {
+      return json({ error: "Test case not found" }, 404);
+    }
+    return json(updated);
+  }
+
+  // DELETE /api/tests/:id - Delete test case
+  if (updateMatch && method === "DELETE") {
+    const deleted = TestCaseDB.delete(updateMatch[1]);
+    if (!deleted) {
+      return json({ error: "Test case not found" }, 404);
+    }
+    return json({ success: true });
+  }
+
+  // POST /api/tests/:id/run - Run single test
+  const runSingleMatch = path.match(/^\/api\/tests\/([^/]+)\/run$/);
+  if (runSingleMatch && method === "POST") {
+    const testCase = TestCaseDB.findById(runSingleMatch[1]);
+    if (!testCase) {
+      return json({ error: "Test case not found" }, 404);
+    }
+
+    const result = await runTest(testCase);
+    return json(result);
+  }
+
+  // POST /api/tests/run - Run all (or filtered) tests
+  if (path === "/api/tests/run" && method === "POST") {
+    const body = await req.json().catch(() => ({})) as any;
+    const testCaseIds = body.test_case_ids as string[] | undefined;
+
+    const results = await runAll(testCaseIds);
+    const passed = results.filter(r => r.status === "passed").length;
+    const failed = results.filter(r => r.status === "failed").length;
+    const errors = results.filter(r => r.status === "error").length;
+
+    return json({
+      summary: { total: results.length, passed, failed, errors },
+      results,
+    });
+  }
+
+  // GET /api/tests/:id/runs - Get run history for a test
+  const runsMatch = path.match(/^\/api\/tests\/([^/]+)\/runs$/);
+  if (runsMatch && method === "GET") {
+    const testCase = TestCaseDB.findById(runsMatch[1]);
+    if (!testCase) {
+      return json({ error: "Test case not found" }, 404);
+    }
+    const runs = TestRunDB.findByTestCase(runsMatch[1]);
+    return json(runs);
+  }
+
+  // GET /api/tests/runs/:runId - Get single run details
+  const runDetailMatch = path.match(/^\/api\/tests\/runs\/([^/]+)$/);
+  if (runDetailMatch && method === "GET") {
+    const run = TestRunDB.findById(runDetailMatch[1]);
+    if (!run) {
+      return json({ error: "Test run not found" }, 404);
+    }
+    return json(run);
+  }
+
+  return null;
+}

package/src/routes/api.ts

@@ -10,6 +10,8 @@ import { handleSkillRoutes } from "./api/skills";
 import { handleIntegrationRoutes } from "./api/integrations";
 import { handleMetaAgentRoutes } from "./api/meta-agent";
 import { handleTelemetryRoutes } from "./api/telemetry";
+import { handleTestRoutes } from "./api/tests";
+import { handleApiKeyRoutes } from "./api/api-keys";
 import { handlePlatformMcpRequest } from "../mcp-platform";
 
 // Re-export for backward compatibility (server.ts dynamic import)
@@ -29,6 +31,7 @@ export async function handleApiRequest(
 
   return (
     (await handleSystemRoutes(req, path, method, authContext)) ??
+    (await handleApiKeyRoutes(req, path, method, authContext)) ?? // Must be before provider routes to handle /api/keys/personal
     (await handleProviderRoutes(req, path, method, authContext)) ??
     (await handleUserRoutes(req, path, method, authContext)) ??
     (await handleProjectRoutes(req, path, method, authContext)) ??
@@ -38,6 +41,7 @@ export async function handleApiRequest(
     (await handleIntegrationRoutes(req, path, method)) ??
     (await handleMetaAgentRoutes(req, path, method)) ??
     (await handleTelemetryRoutes(req, path, method)) ??
+    (await handleTestRoutes(req, path, method)) ??
     json({ error: "Not found" }, 404)
   );
 }

package/src/server.ts

@@ -456,7 +456,8 @@ if (hasRestarts) {
             continue;
           }
 
-          const port = await getNextPort();
+          // Use permanently assigned port from DB, fallback to dynamic
+          const port = server.port || await getNextPort();
           const result = await startMcpProcess(server.id, cmd, serverEnv, port);
 
           if (result.success) {