feat: extend operational investigation workflows

app/mcp/calculation_jobs.py

@@ -39,12 +39,15 @@ def envelope(source: str, data, *, job_id="list", page=None) -> QueryResult:
 
 
 def public_job(row: dict) -> dict:
-    fields = {"job_id", "status", "tool", "created_at", "started_at", "finished_at", "updated_at", "error"}
+    fields = {"job_id", "status", "tool", "created_at", "started_at", "finished_at", "updated_at", "error", "queue_expires_at", "result_expires_at"}
     from fastapi.encoders import jsonable_encoder
-    return {**jsonable_encoder({key: row[key] for key in fields if key in row}), "poll_after_ms": 1500}
+    expiry = row.get("result_expires_at")
+    available = row.get("status") == "succeeded" and (expiry is None or expiry > datetime.now(timezone.utc))
+    return {**jsonable_encoder({key: row[key] for key in fields if key in row}),
+            "result_available": available, "poll_after_ms": 1500}
 
 
-async def submit_calculation(scope, binding, tool, args, call_id: str) -> QueryResult:
+async def submit_calculation(scope, binding, tool, args, call_id: str, *, job_timeout_seconds: int = 3600) -> QueryResult:
     from app.mcp.query_service import authorize_query
     await authorize_query(scope, binding, tool, args)
     if binding.purpose == "task_reader":
@@ -68,7 +71,7 @@ async def submit_calculation(scope, binding, tool, args, call_id: str) -> QueryR
                 if not retryable_capacity_rejection(previous["result"]):
                     raise HTTPException(409, "Operation already started; inspect the existing calculation or mutation status")
         check_digest(args, await preview_change(scope, binding, tool.name, args))
-    parameters = args.model_dump(mode="json", exclude={"context_handle"})
+    parameters = args.model_dump(mode="json", exclude={"context_handle", "timeout_seconds"})
     request_id = str(args.request_id) if tool.mutating else call_id
     key = str(uuid5(NAMESPACE_URL, ":".join([binding.subject, binding.client_id, binding.native_session_id, str(binding.task_id), str(binding.run_id), request_id])))
     repo = CalculationJobRepository(scope.connection, scope.project.project_id)
@@ -84,12 +87,12 @@ async def submit_calculation(scope, binding, tool, args, call_id: str) -> QueryR
             await verify_task(scope, binding)
             row = await repo.enqueue(
                 owner_user_id=scope.project.user_id, request_key=key, tool=tool.name,
-                parameters=parameters, binding=durable_binding(binding), timeout_seconds=args.timeout_seconds,
+                parameters=parameters, binding=durable_binding(binding), timeout_seconds=job_timeout_seconds,
             )
     else:
         row = await repo.enqueue(
             owner_user_id=scope.project.user_id, request_key=key, tool=tool.name,
-            parameters=parameters, binding=durable_binding(binding), timeout_seconds=args.timeout_seconds,
+            parameters=parameters, binding=durable_binding(binding), timeout_seconds=job_timeout_seconds,
         )
     await scope.connection.commit()
     return envelope(tool.name, public_job(row), job_id=row["job_id"])
@@ -107,7 +110,9 @@ async def authorize_original(scope, row):
     from app.mcp.contexts import verify_task
     original = restore_binding(row["binding"])
     tool = TOOLS[row["tool"]]
-    args = tool.model.model_validate({**row["parameters"], "context_handle": "durable-calculation-context-handle"})
+    # Legacy queue rows stored the old HTTP timeout. It does not govern durable execution.
+    parameters = {key: value for key, value in row["parameters"].items() if key != "timeout_seconds"}
+    args = tool.model.model_validate({**parameters, "context_handle": "durable-calculation-context-handle"})
     if (str(scope.project.user_id) != str(row["owner_user_id"])
             or str(scope.project.project_id) != str(original.project_id)):
         raise HTTPException(403, "Calculation owner is no longer authorized")
@@ -125,7 +130,8 @@ async def read_calculation_job(scope, binding, tool, args) -> QueryResult:
         })
         rows = await repo.list(owner_user_id=scope.project.user_id, binding=identity_scope, limit=args.limit + 1, offset=args.offset, status=args.status)
         return envelope(tool.name, [public_job(row) for row in rows[:args.limit]], page=PageInfo(limit=args.limit, offset=args.offset, has_more=len(rows) > args.limit))
-    row = await repo.get(args.job_id, owner_user_id=scope.project.user_id)
+    row = await repo.get(args.job_id, owner_user_id=scope.project.user_id,
+                         include_result=tool.name == "get_calculation_result")
     if row is None:
         raise HTTPException(404, "Calculation was not found")
     check_binding(binding, row)
@@ -137,6 +143,9 @@ async def read_calculation_job(scope, binding, tool, args) -> QueryResult:
         await scope.connection.commit()
     if tool.name != "get_calculation_result" or row["status"] != "succeeded":
         return envelope(tool.name, public_job(row), job_id=row["job_id"])
+    expiry = row.get("result_expires_at")
+    if row.get("result") is None or (expiry is not None and expiry <= datetime.now(timezone.utc)):
+        raise HTTPException(410, "Calculation result retention period has expired")
     result = QueryResult.model_validate(row["result"])
     result = await attach_calculation_evidence(scope, row, result)
     value = result.data