Unified return format

examples/server/server.cpp

@@ -620,6 +620,7 @@ namespace {
         std::string result; // final response body
         std::string content_type = "application/json";
         std::string error; // error message if failed
+    whisper_params params; // copy of the params used for this task
     };
 
     static std::unordered_map<std::string, async_task_t> tasks;
@@ -1185,6 +1186,7 @@ int main(int argc, char ** argv) {
             std::lock_guard<std::mutex> tlock(tasks_mutex);
             tasks[tmp_task_id] = async_task_t();
             tasks[tmp_task_id].status = async_status::PENDING;
+            tasks[tmp_task_id].params = params; // store params used for this sync run
         }
 
         // run in same thread
@@ -1253,6 +1255,7 @@ int main(int argc, char ** argv) {
             std::lock_guard<std::mutex> tlock(tasks_mutex);
             tasks[task_id] = async_task_t();
             tasks[task_id].status = async_status::PENDING;
+            tasks[task_id].params = task_params; // store params for async task
         }
 
         // spawn background worker thread
@@ -1275,9 +1278,12 @@ int main(int argc, char ** argv) {
             return;
         }
         const std::string id = req.get_param_value("id");
-        // copy needed data while holding lock, then release lock and send response
-        std::string out_body;
-        std::string out_ctype;
+
+        json response_json;
+        response_json["status"] = "unknown";
+        response_json["data"] = nullptr;
+        response_json["params"] = json::object();
+
         {
             std::lock_guard<std::mutex> tlock(tasks_mutex);
             auto it = tasks.find(id);
@@ -1287,27 +1293,53 @@ int main(int argc, char ** argv) {
                 return;
             }
 
-            const auto & t = it->second;
+            auto t = it->second; // copy so we can erase while unlocked
+
+            // populate params subset for client inspection
+            json p = json::object();
+            p["temperature"] = t.params.temperature;
+            p["temperature_inc"] = t.params.temperature_inc;
+            p["response_format"] = t.params.response_format;
+            p["n_threads"] = t.params.n_threads;
+            response_json["params"] = p;
+
             if (t.status == async_status::PENDING || t.status == async_status::RUNNING) {
-                json j = { {"status", "processing"} };
-                res.set_content(j.dump(), "application/json");
+                response_json["status"] = "processing";
+                response_json["data"] = nullptr;
+                res.set_content(response_json.dump(), "application/json");
                 return;
             }
+
             if (t.status == async_status::FAILED) {
-                json j = { {"status", "failed"}, {"error", t.error} };
-                out_body = j.dump();
-                out_ctype = "application/json";
+                response_json["status"] = "failed";
+                response_json["data"] = json{{"error", t.error}};
                 // remove failed task from map to avoid accumulation
                 tasks.erase(it);
+                res.set_content(response_json.dump(), "application/json");
+                return;
+            }
+
+            // FINISHED
+            response_json["status"] = "finished";
+
+            // If original requested JSON format, try to parse stored result JSON and return as data
+            if (t.params.response_format == json_format || t.content_type.find("application/json") != std::string::npos) {
+                try {
+                    json parsed = json::parse(t.result);
+                    response_json["data"] = parsed;
+                } catch (...) {
+                    response_json["data"] = t.result;
+                }
             } else {
-                // FINISHED: copy and erase the task so it's cleaned up after retrieval
-                out_body = t.result;
-                out_ctype = t.content_type;
-                tasks.erase(it);
+                // non-json content -> return as string under data.content
+                response_json["data"] = json{{"content", t.result}, {"content_type", t.content_type}};
             }
+
+            // remove the task after building the response
+            tasks.erase(it);
         }
 
-        res.set_content(out_body, out_ctype);
+        res.set_content(response_json.dump(), "application/json");
     });
     svr->Post(sparams.request_path + "/load", [&](const Request &req, Response &res){
         std::lock_guard<std::mutex> lock(whisper_mutex);