feat: plans - longrunning tasks

traderai/server.py

@@ -23,6 +23,7 @@ from traderai.config import save_settings, settings_payload
 from traderai.config import get_settings
 from traderai.cornerstone_client import CornerstoneClient
 from traderai.memory import DEFAULT_THREAD_ID, MemoryStore
+from traderai.plans import ContinualPlanRunner, ContinualPlanStore
 from traderai.scheduler import WakeScheduler
 from traderai.scmdb_client import SCMDBClient
 from traderai.tools import ToolRegistry
@@ -60,6 +61,27 @@ class ClearMemoryRequest(BaseModel):
     include_outbox: bool = True
 
 
+class ContinualPlanItemRequest(BaseModel):
+    item_name: str
+    desired_quantity: int = 1
+    max_unit_price: float | None = None
+
+
+class ContinualPlanCreateRequest(BaseModel):
+    title: str
+    objective: str
+    kind: str = "buying"
+    cadence: str | None = None
+    constraints: dict[str, Any] = {}
+    items: list[ContinualPlanItemRequest] = []
+
+
+class ContinualPlanEventRequest(BaseModel):
+    kind: str = "note"
+    message: str
+    metadata: dict[str, Any] = {}
+
+
 class ConfigUpdateRequest(BaseModel):
     values: dict
 
@@ -75,6 +97,7 @@ UPDATE_ASSET_NAME = "TraderAI.exe"
 def create_app() -> FastAPI:
     settings = get_settings()
     memory = MemoryStore(settings.traderai_memory_path)
+    plan_store = ContinualPlanStore(memory)
     scheduler = WakeScheduler(memory)
     uex = UEXClient(settings.uex_base_url, settings.uex_secret_key, settings.uex_bearer_token)
     scmdb = SCMDBClient(settings.scmdb_base_url)
@@ -86,7 +109,10 @@ def create_app() -> FastAPI:
         scheduler=scheduler,
         scmdb=scmdb,
         cornerstone=cornerstone,
+        plan_store=plan_store,
     )
+    plan_runner = ContinualPlanRunner(plan_store, tools, memory)
+    tools.plan_runner = plan_runner
     agent = OllamaAgent(
         settings.ollama_base_url,
         settings.ollama_model,
@@ -95,7 +121,9 @@ def create_app() -> FastAPI:
         user_name=settings.traderai_user_name,
         num_ctx=settings.ollama_num_ctx,
     )
+    plan_runner.bind_agent(agent)
     scheduler.bind_agent(agent)
+    scheduler.bind_plan_runner(plan_runner)
     scheduler.bind_uex_notifications(uex, settings.uex_notification_poll_seconds)
 
     app = FastAPI(title="TraderAI")
@@ -348,6 +376,66 @@ def create_app() -> FastAPI:
     async def wake_jobs() -> dict:
         return {"scheduled_jobs": scheduler.list_jobs()}
 
+    @app.get("/api/plans")
+    async def continual_plans(include_inactive: bool = True) -> dict:
+        return {"plans": plan_store.list_plans(include_inactive=include_inactive)}
+
+    @app.post("/api/plans")
+    async def create_continual_plan(request: ContinualPlanCreateRequest) -> dict:
+        result = await tools.create_continual_plan(
+            title=request.title,
+            objective=request.objective,
+            kind=request.kind,
+            items=[item.model_dump() for item in request.items],
+            constraints=request.constraints,
+            cadence=request.cadence,
+        )
+        if result.get("error"):
+            raise HTTPException(status_code=400, detail=result["error"])
+        return result
+
+    @app.get("/api/plans/{plan_id}")
+    async def continual_plan(plan_id: str) -> dict:
+        plan = plan_store.get_plan(plan_id)
+        if not plan:
+            raise HTTPException(status_code=404, detail="Plan not found.")
+        return {"plan": plan}
+
+    @app.post("/api/plans/{plan_id}/pause")
+    async def pause_continual_plan(plan_id: str) -> dict:
+        result = await tools.pause_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/resume")
+    async def resume_continual_plan(plan_id: str) -> dict:
+        result = await tools.resume_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/cancel")
+    async def cancel_continual_plan(plan_id: str) -> dict:
+        result = await tools.cancel_continual_plan(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=404, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/run")
+    async def run_continual_plan(plan_id: str) -> dict:
+        result = await tools.run_continual_plan_now(plan_id)
+        if result.get("error"):
+            raise HTTPException(status_code=400, detail=result["error"])
+        return result
+
+    @app.post("/api/plans/{plan_id}/events")
+    async def add_continual_plan_event(plan_id: str, request: ContinualPlanEventRequest) -> dict:
+        if not plan_store.get_plan(plan_id):
+            raise HTTPException(status_code=404, detail="Plan not found.")
+        event = plan_store.add_event(plan_id, request.kind, request.message, request.metadata)
+        return {"event": event, "plan": plan_store.get_plan(plan_id)}
+
     @app.get("/api/memory")
     async def inspect_memory(limit: int = 50) -> dict:
         return memory.inspect(max(1, min(limit, 200)))