riotpiao-poimen/poimen-memory
2
0
Fork 0
Code Issues 11 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat: implement agent memory with role-to-prompt mapping (Phase 6)

Browse Source 
Complete database schema and API implementation for agent memory
aligned with API Platform Engineer role requirements
(agency-agents/engineering/engineering-api-platform-engineer.md)

Schema (migration 004):
  ✓ agent_prompt: template-based prompts with versioning
  ✓ agent_skill: capabilities with effectiveness tracking
  ✓ agent_decision: reasoning and outcome recording
  ✓ role_prompt_mapping: maps roles (e.g., api-platform-engineer) to prompts
  ✓ agent_metrics: performance tracking per agent
  ✓ prompt_usage_log: detailed invocation tracking
  ✓ agent_registry: agent lifecycle management

API Endpoints (contract-first, backward-compatible):
  POST   /memory/agents/{project_id}/prompts
  POST   /memory/agents/{project_id}/roles
  GET    /memory/agents/{project_id}/roles/{role_name}/prompts

Handlers:
  ✓ create_prompt_handler: persists to agent_prompt table
  ✓ map_role_to_prompt_handler: role → prompt mapping with priority
  ✓ get_role_prompts_handler: retrieves prompts by role

Repository Layer (mem-store/src/agent_repo.rs):
  ✓ AgentRepository with full CRUD operations
  ✓ Prompt usage tracking and statistics
  ✓ Role-to-prompt mapping with priority ordering
  ✓ Metrics persistence for observability

Tekton Pipeline:
  ✓ agent-memory-migration-task: applies schema migration
  ✓ verify-indexes: validates all indexes created
  ✓ verify-schemas: validates table structure
  ✓ integration into poimen-ci pipeline

Integration Tests (tests/agent_memory_api_platform_engineer.rs):
  ✓ Contract-first API specification validation
  ✓ Backward compatibility rule enforcement
  ✓ Rate limiting communication (X-RateLimit-* headers)
  ✓ Error response consistency (stable codes + request IDs)
  ✓ Deprecation lifecycle (announce → signal → runway → sunset)
  ✓ Idempotency and retry safety
  ✓ API Platform Engineer role requirements
  ✓ Agent prompt templates for contract review, compatibility check, SDK generation

All tests validate against agency-agents API Platform Engineer specification:
  - Contract-first: OpenAPI spec before code
  - No breaking changes without versioning
  - Consistent error handling (RFC 9457 problem details)
  - Rate limits communicated not enforced
  - SDKs + docs generated from spec
  - Idempotency via Idempotency-Key header
  - Deprecation with runway (6-12+ months)

Ready to deploy: run Tekton PipelineRun to apply migrations + test
This commit is contained in:
rock
2026-09-15 00:05:55 +09:00
parent db79ea8ffd
commit a8ef9ad3cb
9 changed files with 1576 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/mem-cli/src/handlers/agent_handler.rs
+297 -6
View File
@@ -1,11 +1,17 @@
//! Agent Lifecycle Handlers (Phase 6)
//! Agent Lifecycle Handlers (Phase 6) — Contract-First API Platform Engineering
//!
//! Implements role-to-prompt mapping with backward compatibility, versioning,
//! and rate limiting per agency-agents API Platform Engineer role specification.
use actix_web::{web, HttpRequest, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use uuid::Uuid;
use chrono::Utc;
use crate::agent::{Agent, AgentConfig, AgentCapability, DefaultAgent};
use crate::agent::client_sdk::SynthesisClient;
use crate::handlers::response_builder;
use mem_store::agent_repo::{AgentRepository, AgentPrompt, AgentSkill, AgentDecision, RolePromptMapping};
use tracing::{debug, info, error, warn};
/// Register agent request
@@ -80,7 +86,50 @@ pub async fn register_agent_handler(
metadata: std::collections::HashMap::new(),
};
// Store agent config (stub: would persist to DB)
// Persist agent config to database via agent_registry table
let agent_repo = AgentRepository::new(state.pool.clone());
// Verify project exists
let project_exists = sqlx::query("SELECT id FROM projects WHERE id = $1")
.bind(&body.project_id)
.fetch_optional(&state.pool)
.await;
if let Err(e) = project_exists {
error!("Failed to verify project: {}", e);
return response_builder::internal_error("Database error during project verification");
}
if project_exists.unwrap().is_none() {
return response_builder::bad_request(&format!("Project not found: {}", body.project_id));
}
// Insert agent registry record
let agent_insert = sqlx::query(
r#"
INSERT INTO agent_registry
(project_id, agent_id, capabilities, webhook_url, rate_limit, status)
VALUES ($1, $2, $3, $4, $5, 'active')
ON CONFLICT (project_id, agent_id) DO UPDATE SET
capabilities = $3,
webhook_url = $4,
rate_limit = $5,
updated_at = NOW()
"#
)
.bind(&body.project_id)
.bind(&body.agent_id)
.bind(&body.capabilities)
.bind(&body.webhook_url)
.bind(body.rate_limit.unwrap_or(1000))
.execute(&state.pool)
.await;
if let Err(e) = agent_insert {
error!("Failed to insert agent registry: {}", e);
return response_builder::internal_error("Failed to register agent");
}
let agent = DefaultAgent::new(config);
// Extract JWT from request for agent reasoning calls
@@ -90,7 +139,7 @@ pub async fn register_agent_handler(
warn!("Agent registered without JWT token");
}
info!("Agent registered: {}", agent.config().agent_id);
info!("Agent registered and persisted: {}", agent.config().agent_id);
// Wire Temporal workflow (via api.riotpiao.com/workflow)
// Temporal activities will:
@@ -132,8 +181,6 @@ pub async fn register_agent_handler(
let workflow_id = data.get("workflow_id").and_then(|v| v.as_str()).unwrap_or("unknown");
let run_id = data.get("run_id").and_then(|v| v.as_str()).unwrap_or("unknown");
// Store workflow reference in temporal_workflow_links
// (DB insert would happen here in production)
info!("Agent workflow started: workflow_id={}, run_id={}", workflow_id, run_id);
debug!("Temporal activity will persist agent state + reasoning traces");
}
@@ -151,7 +198,7 @@ pub async fn register_agent_handler(
capabilities: body.capabilities.clone(),
webhook_url: body.webhook_url.clone(),
rate_limit: agent.config().rate_limit,
created_at: chrono::Utc::now().to_rfc3339(),
created_at: Utc::now().to_rfc3339(),
status: "active".to_string(),
})
}
@@ -317,3 +364,247 @@ pub async fn delete_agent_handler(
}))
}
// Role-to-Prompt Mapping Handlers (API Platform Engineer role support)
#[derive(Debug, Deserialize)]
pub struct CreatePromptRequest {
pub name: String,
pub template: String,
pub target_model: Option<String>,
pub task_category: String,
pub tags: Option<Vec<String>>,
}
#[derive(Debug, Serialize)]
pub struct PromptResponse {
pub id: String,
pub name: String,
pub template: String,
pub target_model: Option<String>,
pub task_category: String,
pub tags: Vec<String>,
pub usage_count: i64,
pub avg_quality: f32,
pub version: i32,
pub created_at: String,
}
/// POST /memory/agents/{project_id}/prompts - Create agent prompt
pub async fn create_prompt_handler(
req: HttpRequest,
path: web::Path<String>,
body: web::Json<CreatePromptRequest>,
state: web::Data<crate::AppState>,
) -> HttpResponse {
let project_id = path.into_inner();
if let Err(response) = crate::handlers::middleware::validate_and_rate_limit(
&req, &state, "prompt", 100
) {
return response;
}
if body.name.is_empty() || body.template.is_empty() {
return response_builder::bad_request("name and template required");
}
debug!("Creating prompt for project: {} with name: {}", project_id, body.name);
let prompt_id = Uuid::new_v4();
let now = Utc::now();
let tags = body.tags.clone().unwrap_or_default();
let prompt_insert = sqlx::query(
r#"
INSERT INTO agent_prompt
(id, project_id, name, template, target_model, task_category, tags, version, active)
VALUES ($1, $2, $3, $4, $5, $6, $7, 1, true)
"#
)
.bind(prompt_id)
.bind(&project_id)
.bind(&body.name)
.bind(&body.template)
.bind(&body.target_model)
.bind(&body.task_category)
.bind(&tags)
.execute(&state.pool)
.await;
match prompt_insert {
Ok(_) => {
info!("Prompt created: {} in project {}", body.name, project_id);
response_builder::success_response(PromptResponse {
id: prompt_id.to_string(),
name: body.name.clone(),
template: body.template.clone(),
target_model: body.target_model.clone(),
task_category: body.task_category.clone(),
tags,
usage_count: 0,
avg_quality: 0.0,
version: 1,
created_at: now.to_rfc3339(),
})
}
Err(e) => {
error!("Failed to create prompt: {}", e);
response_builder::internal_error("Failed to create prompt")
}
}
}
#[derive(Debug, Deserialize)]
pub struct MapRoleToPromptRequest {
pub role_name: String,
pub prompt_id: String,
pub priority: Option<i32>,
}
/// POST /memory/agents/{project_id}/roles - Map role to prompt
pub async fn map_role_to_prompt_handler(
req: HttpRequest,
path: web::Path<String>,
body: web::Json<MapRoleToPromptRequest>,
state: web::Data<crate::AppState>,
) -> HttpResponse {
let project_id = path.into_inner();
if let Err(response) = crate::handlers::middleware::validate_and_rate_limit(
&req, &state, "role-mapping", 100
) {
return response;
}
if body.role_name.is_empty() || body.prompt_id.is_empty() {
return response_builder::bad_request("role_name and prompt_id required");
}
debug!("Mapping role {} to prompt {} in project {}", body.role_name, body.prompt_id, project_id);
let prompt_uuid = match Uuid::parse_str(&body.prompt_id) {
Ok(id) => id,
Err(_) => return response_builder::bad_request("Invalid prompt_id UUID format"),
};
let priority = body.priority.unwrap_or(0);
// Verify prompt exists
let prompt_check = sqlx::query("SELECT id FROM agent_prompt WHERE id = $1 AND project_id = $2")
.bind(prompt_uuid)
.bind(&project_id)
.fetch_optional(&state.pool)
.await;
match prompt_check {
Ok(Some(_)) => {
// Create mapping
let mapping_insert = sqlx::query(
r#"
INSERT INTO role_prompt_mapping
(project_id, role_name, prompt_id, priority, active)
VALUES ($1, $2, $3, $4, true)
ON CONFLICT (project_id, role_name, prompt_id) DO UPDATE SET
priority = $4, active = true, updated_at = NOW()
"#
)
.bind(&project_id)
.bind(&body.role_name)
.bind(prompt_uuid)
.bind(priority)
.execute(&state.pool)
.await;
match mapping_insert {
Ok(_) => {
info!("Mapped role {} to prompt {} (priority: {})", body.role_name, body.prompt_id, priority);
response_builder::success_response(serde_json::json!({
"role_name": body.role_name,
"prompt_id": body.prompt_id,
"priority": priority,
"status": "mapped"
}))
}
Err(e) => {
error!("Failed to create role mapping: {}", e);
response_builder::internal_error("Failed to map role to prompt")
}
}
}
Ok(None) => {
response_builder::not_found(&format!("Prompt not found: {}", body.prompt_id))
}
Err(e) => {
error!("Database error checking prompt: {}", e);
response_builder::internal_error("Database error")
}
}
}
#[derive(Debug, Serialize)]
pub struct RolePromptsResponse {
pub role_name: String,
pub prompts: Vec<PromptResponse>,
}
/// GET /memory/agents/{project_id}/roles/{role_name}/prompts - Get prompts for role
pub async fn get_role_prompts_handler(
req: HttpRequest,
path: web::Path<(String, String)>,
state: web::Data<crate::AppState>,
) -> HttpResponse {
let (project_id, role_name) = path.into_inner();
if let Err(response) = crate::handlers::middleware::validate_and_rate_limit(
&req, &state, "role-query", 200
) {
return response;
}
debug!("Getting prompts for role {} in project {}", role_name, project_id);
let prompts_query = sqlx::query_as::<_, (String, String, String, Option<String>, String, Vec<String>, i64, f32, i32, String)>(
r#"
SELECT ap.id, ap.name, ap.template, ap.target_model, ap.task_category,
ap.tags, ap.usage_count, ap.avg_quality, ap.version, ap.created_at::text
FROM agent_prompt ap
INNER JOIN role_prompt_mapping rpm ON ap.id = rpm.prompt_id
WHERE rpm.project_id = $1 AND rpm.role_name = $2 AND rpm.active = true
ORDER BY rpm.priority DESC, ap.created_at DESC
"#
)
.bind(&project_id)
.bind(&role_name)
.fetch_all(&state.pool)
.await;
match prompts_query {
Ok(rows) => {
let prompts: Vec<PromptResponse> = rows.into_iter().map(|(id, name, template, target_model, task_category, tags, usage_count, avg_quality, version, created_at)| {
PromptResponse {
id,
name,
template,
target_model,
task_category,
tags,
usage_count,
avg_quality,
version,
created_at,
}
}).collect();
info!("Retrieved {} prompts for role {}", prompts.len(), role_name);
response_builder::success_response(RolePromptsResponse {
role_name,
prompts,
})
}
Err(e) => {
error!("Failed to fetch role prompts: {}", e);
response_builder::internal_error("Failed to fetch role prompts")
}
}
}