#include "deepseek/responses.h" #include #include "deepseek/calls.h" #include "deepseek/caps.h" #include "deepseek/rules.h" namespace molo::deepseek { // ---- builders -------------------------------------------------------------- Json ResponseItems::message(const std::string& role, const std::string& text) { Json m = Json::object(); m.set("type", Json("message")); m.set("role", Json(role)); m.set("content", Json(text)); return m; } Json ResponseItems::message_parts(const std::string& role, const std::vector& parts) { Json arr = Json::array(); for (const Json& p : parts) arr.push(p); Json m = Json::object(); m.set("type", Json("message")); m.set("role", Json(role)); m.set("content", arr); return m; } Json ResponseItems::input_text(const std::string& text) { Json p = Json::object(); p.set("type", Json("input_text")); p.set("text", Json(text)); return p; } Json ResponseItems::input_image_url(const std::string& url, const std::string& detail) { Json p = Json::object(); p.set("type", Json("input_image")); p.set("image_url", Json(url)); if (!detail.empty()) p.set("detail", Json(detail)); return p; } Json ResponseItems::input_image_file(const std::string& file_id) { Json p = Json::object(); p.set("type", Json("input_image")); p.set("file_id", Json(file_id)); return p; } Json ResponseItems::function_call(const std::string& call_id, const std::string& name, const std::string& arguments) { Json m = Json::object(); m.set("type", Json("function_call")); m.set("call_id", Json(call_id)); m.set("name", Json(name)); m.set("arguments", Json(arguments)); return m; } Json ResponseItems::function_call_output(const std::string& call_id, const std::string& output) { Json m = Json::object(); m.set("type", Json("function_call_output")); m.set("call_id", Json(call_id)); m.set("output", Json(output)); return m; } Json ResponseItems::function_call_output_parts(const std::string& call_id, const std::vector& parts) { Json arr = Json::array(); for (const Json& p : parts) arr.push(p); Json m = Json::object(); m.set("type", Json("function_call_output")); m.set("call_id", Json(call_id)); m.set("output", arr); return m; } Json ResponseItems::reasoning(const std::string& text) { Json part = Json::object(); part.set("type", Json("reasoning_text")); part.set("text", Json(text)); Json content = Json::array(); content.push(part); Json m = Json::object(); m.set("type", Json("reasoning")); m.set("content", content); return m; } Json ResponseItems::function_tool(const std::string& name, const std::string& description, const Json& parameters) { Json t = Json::object(); t.set("type", Json("function")); t.set("name", Json(name)); if (!description.empty()) t.set("description", Json(description)); t.set("parameters", parameters); return t; } Json ResponseItems::web_search_tool() { Json t = Json::object(); t.set("type", Json("web_search")); return t; } Json ResponseItems::apply_patch_tool() { Json t = Json::object(); t.set("type", Json("custom")); t.set("name", Json("apply_patch")); return t; } // ---- validation ------------------------------------------------------------ namespace { void check_image(const Json& p) { bool url = p.has("image_url"), file = p.has("file_id"); Rules::require(url || file, "input_image must have image_url or file_id"); Rules::require(!(url && file), "input_image cannot have both image_url and file_id"); if (url) Rules::image_url(J::str(p, "image_url")); if (file) Rules::require(!J::str(p, "file_id").empty(), "file_id must not be empty"); Rules::detail(J::str(p, "detail")); } void check_content(const Json& content, bool images_ok, std::size_t& images) { if (content.is_string()) return; Rules::require(content.is_array(), "content must be a string or an array of parts"); for (const Json& p : content.as_array()) { Rules::require(p.is_object(), "content part must be an object"); std::string type = J::str(p, "type"); if (type == "input_text" || type == "output_text") { Rules::require(p.find("text") && p.find("text")->is_string(), "text part needs text"); } else if (type == "input_image") { Rules::require(images_ok, "images are allowed only in user / developer messages and tool outputs"); check_image(p); ++images; } else if (type == "reasoning_text") { Rules::require(p.find("text") && p.find("text")->is_string(), "reasoning_text part needs text"); } else { Rules::fail("unknown content part type '" + type + "' (file inputs are not supported)"); } } } void check_items(const Json& items) { Rules::require(items.as_array().size() <= DeepseekCaps::kMaxMessages, "too many input items"); std::set calls, outputs, custom_calls, custom_outputs; std::size_t images = 0; for (const Json& it : items.as_array()) { Rules::require(it.is_object(), "input item must be an object"); std::string type = J::str(it, "type"); if (type.empty() && it.has("role")) type = "message"; if (type == "message") { std::string role = J::str(it, "role"); Rules::require(role == "user" || role == "assistant" || role == "system" || role == "developer", "message role must be user, assistant, system or developer"); const Json* c = it.find("content"); Rules::require(c, "message needs content"); check_content(*c, role == "user" || role == "developer", images); } else if (type == "function_call" || type == "custom_tool_call") { std::string id = J::str(it, "call_id"); Rules::require(!id.empty(), type + " needs call_id"); Rules::tool_name(J::str(it, "name")); auto& set = type == "function_call" ? calls : custom_calls; Rules::require(set.insert(id).second, "call_id values must be unique"); } else if (type == "function_call_output" || type == "custom_tool_call_output") { std::string id = J::str(it, "call_id"); Rules::require(!id.empty(), type + " needs call_id"); const Json* o = it.find("output"); Rules::require(o, type + " needs output"); check_content(*o, true, images); (type == "function_call_output" ? outputs : custom_outputs).insert(id); } else if (type == "reasoning") { const Json* c = it.find("content"); Rules::require(c && c->is_array(), "reasoning item needs a content array"); check_content(*c, false, images); } else if (type == "web_search_call") { // restored search results of a previous response: opaque } else { Rules::fail("input item type '" + type + "' is not supported (the server would ignore it)"); } } for (const std::string& id : calls) Rules::require(outputs.count(id) == 1, "every function_call needs a function_call_output"); for (const std::string& id : custom_calls) Rules::require(custom_outputs.count(id) == 1, "every custom_tool_call needs a custom_tool_call_output"); Rules::require(images <= DeepseekCaps::kMaxImages, "at most 600 images per request"); } } // namespace void ResponsesParams::validate() const { Rules::model(model); bool has_text = input_text.has_value(); bool has_items = input_items.is_array() && !input_items.as_array().empty(); Rules::require(!(has_text && has_items), "give input as text or as items, not both"); Rules::require(has_text || has_items || !instructions.empty(), "at least one of input and instructions is required"); if (has_items) check_items(input_items); if (!effort.empty()) Rules::effort(effort); if (max_output_tokens) Rules::require(*max_output_tokens >= 1 && *max_output_tokens <= DeepseekCaps::kMaxTokensCeiling, "max_output_tokens must be 1..393216"); if (temperature) Rules::range(*temperature, 0, 2, "temperature"); if (top_p) Rules::top_p(*top_p); if (format == TextFormat::kJsonSchema) { Rules::require(!schema_name.empty(), "json_schema needs a name"); Rules::require(schema.is_object() && !schema.as_object().empty(), "json_schema needs a schema"); } if (top_logprobs) Rules::require(*top_logprobs >= 0 && *top_logprobs <= DeepseekCaps::kMaxTopLogprobs, "top_logprobs must be 0..20"); if (!user.empty()) Rules::user_id(user); Rules::require(tools.is_array() && tools.as_array().size() <= DeepseekCaps::kMaxTools, "too many tools"); std::set names; for (const Json& t : tools.as_array()) { Rules::require(t.is_object(), "tool must be an object"); std::string type = J::str(t, "type"); if (type == "function") { Rules::tool_name(J::str(t, "name")); Rules::require(names.insert(J::str(t, "name")).second, "tool names must be unique"); } else if (type == "custom") { Rules::require(J::str(t, "name") == "apply_patch", "the only custom tool is apply_patch"); } else if (type != "web_search") { Rules::fail("tool type must be function, custom or web_search"); } } if (!tool_choice.empty()) { bool mode = tool_choice == "none" || tool_choice == "auto" || tool_choice == "required"; if (!mode) { Rules::tool_name(tool_choice); Rules::require(names.count(tool_choice) == 1, "tool_choice names a tool that is not defined"); } else if (tool_choice == "required") { Rules::require(!tools.as_array().empty(), "tool_choice required needs tools"); } } } Json ResponsesParams::to_json(bool stream) const { validate(); Json b = Json::object(); b.set("model", Json(model)); if (input_text) b.set("input", Json(*input_text)); else if (!input_items.as_array().empty()) b.set("input", input_items); if (!instructions.empty()) b.set("instructions", Json(instructions)); if (!effort.empty()) { Json r = Json::object(); r.set("effort", Json(effort)); b.set("reasoning", r); } if (max_output_tokens) b.set("max_output_tokens", Json(*max_output_tokens)); if (stream) b.set("stream", Json(true)); if (temperature) b.set("temperature", Json(*temperature)); if (top_p) b.set("top_p", Json(*top_p)); if (format != TextFormat::kText) { Json f = Json::object(); if (format == TextFormat::kJsonObject) { f.set("type", Json("json_object")); } else { f.set("type", Json("json_schema")); f.set("name", Json(schema_name)); f.set("schema", schema); } Json t = Json::object(); t.set("format", f); b.set("text", t); } if (!tools.as_array().empty()) b.set("tools", tools); if (!tool_choice.empty()) { if (tool_choice == "none" || tool_choice == "auto" || tool_choice == "required") { b.set("tool_choice", Json(tool_choice)); } else { Json tc = Json::object(); tc.set("type", Json("function")); tc.set("name", Json(tool_choice)); b.set("tool_choice", tc); } } if (top_logprobs) b.set("top_logprobs", Json(*top_logprobs)); if (!user.empty()) b.set("user", Json(user)); return b; } // ---- results --------------------------------------------------------------- namespace { std::string join_parts(const Json& output, const char* item_type, const char* part_type) { std::string out; for (const Json& item : output.as_array()) { if (J::str(item, "type") != item_type) continue; if (const Json* c = J::arr(item, "content")) for (const Json& p : c->as_array()) if (J::str(p, "type") == part_type) out += J::str(p, "text"); } return out; } } // namespace std::string ResponsesResult::output_text() const { return join_parts(output, "message", "output_text"); } std::string ResponsesResult::reasoning_text() const { return join_parts(output, "reasoning", "reasoning_text"); } std::vector ResponsesResult::function_calls() const { std::vector out; for (const Json& item : output.as_array()) if (J::str(item, "type") == "function_call") out.push_back({J::str(item, "call_id"), J::str(item, "name"), J::str(item, "arguments")}); return out; } ResponsesResult ResponsesResult::parse(const Json& doc) { if (!doc.is_object()) throw llm::ApiError("deepseek", 502, "BAD_RESPONSE", "response is not an object"); ResponsesResult r; r.raw = doc; r.id = J::str(doc, "id"); r.model = J::str(doc, "model"); r.status = J::str(doc, "status"); r.created_at = J::num(doc, "created_at"); if (const Json* e = doc.find("error"); e && e->is_object()) r.error = *e; if (const Json* d = J::obj(doc, "incomplete_details")) r.incomplete_reason = J::str(*d, "reason"); if (const Json* o = J::arr(doc, "output")) r.output = *o; r.usage = TokenUsage::from_response(doc.find("usage")); return r; } std::string ResponseEvent::text_delta() const { if (type.size() > 6 && type.compare(type.size() - 6, 6, ".delta") == 0) return J::str(data, "delta"); return ""; } ResponsesResult Responses::create(const ResponsesParams& params) { Json body = params.to_json(false); return ResponsesResult::parse(client_->post(Calls::render(Call::kResponses), body)); } ResponsesResult Responses::stream(const ResponsesParams& params, const std::function& on_event) { Json body = params.to_json(true); ResponsesResult final_result; bool terminal = false, stopped = false; std::size_t events = 0; client_->stream(Calls::render(Call::kResponses), body, [&](const llm::SseEvent& ev) { if (++events > DeepseekCaps::kMaxStreamEvents) throw llm::ApiError("deepseek", 502, "BAD_RESPONSE", "stream over the event cap"); ResponseEvent e; e.type = J::str(ev.data, "type", ev.event); e.sequence_number = J::num(ev.data, "sequence_number"); e.data = ev.data; if (e.type == "response.completed" || e.type == "response.incomplete" || e.type == "response.failed") { if (const Json* r = J::obj(ev.data, "response")) final_result = ResponsesResult::parse(*r); terminal = true; } if (on_event && !on_event(e)) { stopped = true; return false; } return true; }); if (!terminal && !stopped) throw llm::ApiError("deepseek", 502, "STREAM_TRUNCATED", "stream ended without a terminal response event"); return final_result; } } // namespace molo::deepseek