Merge branch 'worktree-agent-a058017f4f5ead787'
This commit is contained in:
@@ -0,0 +1,37 @@
|
||||
// Routes: GET /ai/mistral (page), /status, /calls (no credential needed)
|
||||
#include <cstdlib>
|
||||
|
||||
#include "support/Assert.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
setenv("MOLO_ENV_FILES", "off", 1);
|
||||
unsetenv("MISTRAL_API_KEY");
|
||||
Fixture f;
|
||||
auto page = f.client->get("/ai/mistral");
|
||||
check(page.status == 200, "page 200");
|
||||
check(contains(page.headers.get("Content-Type"), "text/html"), "html");
|
||||
check(contains(page.body, "Mistral La Plateforme") && contains(page.body, "viewport"), "title and mobile viewport");
|
||||
check(contains(page.body, "/embedded/ai_mistral.js"), "script wired");
|
||||
check(f.client->post("/ai/mistral", "{}", "application/json").status == 405, "post page is 405");
|
||||
|
||||
auto st = f.client->get("/ai/mistral/status");
|
||||
check(st.status == 200 && contains(st.body, "\"configured\":false"), "status without a key");
|
||||
check(contains(st.body, "MISTRAL_API_KEY") && contains(st.body, "mistral-small-latest") &&
|
||||
contains(st.body, "codestral-latest") && contains(st.body, "mistral-embed"),
|
||||
"status names credential env and default models");
|
||||
check(contains(st.body, "\"calls\":347"), "status counts the call table");
|
||||
check(f.client->post("/ai/mistral/status", "{}", "application/json").status == 405, "post status is 405");
|
||||
|
||||
auto calls = f.client->get("/ai/mistral/calls");
|
||||
check(calls.status == 200 && contains(calls.body, "/v1/chat/completions") &&
|
||||
contains(calls.body, "/v1/fim/completions") && contains(calls.body, "/v1/ocr") &&
|
||||
contains(calls.body, "/v1/batch/jobs"),
|
||||
"call table listed");
|
||||
auto chat_only = f.client->get("/ai/mistral/calls?area=chat");
|
||||
check(chat_only.status == 200 && contains(chat_only.body, "/v1/chat/completions") &&
|
||||
!contains(chat_only.body, "/v1/ocr"),
|
||||
"call table filters by area");
|
||||
return finish("ai/mistral/page");
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
// Routes: POST /ai/mistral/* (405, 422, dry runs, 503 without a credential)
|
||||
#include <cstdlib>
|
||||
|
||||
#include "support/Assert.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
setenv("MOLO_ENV_FILES", "off", 1);
|
||||
unsetenv("MISTRAL_API_KEY");
|
||||
Fixture f;
|
||||
auto post = [&](const std::string& route, const std::string& body) {
|
||||
return f.client->post("/ai/mistral/" + route, body, "application/json");
|
||||
};
|
||||
const char* all[] = {"chat", "stream", "agent", "fim", "embeddings", "moderation", "classify", "ocr",
|
||||
"transcribe", "models", "files", "batch", "finetune", "agents", "conversations",
|
||||
"libraries", "operation"};
|
||||
for (const char* r : all) {
|
||||
std::string route = std::string("/ai/mistral/") + r;
|
||||
check(f.client->get(route).status == 405, route + " get is 405");
|
||||
check(post(r, "not json").status == 422, route + " bad json is 422");
|
||||
check(post(r, "[1]").status == 422, route + " non-object is 422");
|
||||
}
|
||||
// 422: input rules run before anything else
|
||||
check(post("chat", "{}").status == 422, "chat needs prompt");
|
||||
check(post("chat", "{\"prompt\":\"hi\",\"temperature\":2}").status == 422, "temperature over 1.5");
|
||||
check(post("chat", "{\"prompt\":\"hi\",\"max_tokens\":-1}").status == 422, "negative max_tokens");
|
||||
check(post("chat", "{\"prompt\":\"hi\",\"effort\":\"loud\"}").status == 422, "bad effort");
|
||||
check(post("agent", "{\"prompt\":\"hi\"}").status == 422, "agent needs agent_id");
|
||||
check(post("agent", "{\"agent_id\":\"a/b\",\"prompt\":\"hi\"}").status == 422, "bad agent id");
|
||||
check(post("fim", "{}").status == 422, "fim needs prompt");
|
||||
check(post("embeddings", "{}").status == 422, "embeddings needs input");
|
||||
check(post("moderation", "{}").status == 422, "moderation needs input");
|
||||
check(post("classify", "{\"input\":\"x\"}").status == 422, "classify needs model");
|
||||
check(post("ocr", "{\"reference\":\"ftp://x\"}").status == 422, "ocr needs http(s)");
|
||||
check(post("ocr", "{\"kind\":\"video\",\"reference\":\"https://x.test/a\"}").status == 422, "bad ocr kind");
|
||||
check(post("transcribe", "{}").status == 422, "transcribe needs a source");
|
||||
check(post("transcribe", "{\"file_url\":\"https://x.test/a.mp3\",\"file_id\":\"f1\"}").status == 422, "one source only");
|
||||
check(post("files", "{\"action\":\"fly\"}").status == 422, "bad files action");
|
||||
check(post("files", "{\"action\":\"get\",\"id\":\"../x\"}").status == 422, "bad file id");
|
||||
check(post("files", "{\"action\":\"upload\",\"filename\":\"a.jsonl\",\"data_base64\":\"@@\"}").status == 422, "bad base64");
|
||||
check(post("files", "{\"action\":\"upload\",\"filename\":\"a/b\",\"data_base64\":\"aGVsbG8=\"}").status == 422, "bad filename");
|
||||
check(post("files", "{\"action\":\"list\",\"page_size\":101}").status == 422, "page_size over 100");
|
||||
check(post("batch", "{\"action\":\"create\",\"model\":\"m\"}").status == 422, "batch needs input files");
|
||||
check(post("batch", "{\"action\":\"get\"}").status == 422, "batch get needs id");
|
||||
check(post("finetune", "{\"action\":\"create\",\"model\":\"open-mistral-7b\"}").status == 422, "finetune needs files");
|
||||
check(post("agents", "{\"action\":\"create\",\"model\":\"m\"}").status == 422, "agent create needs name");
|
||||
check(post("conversations", "{\"action\":\"start\",\"prompt\":\"\"}").status == 422, "empty conversation prompt");
|
||||
check(post("libraries", "{\"action\":\"create\",\"name\":\"n\",\"chunk_size\":10}").status == 422, "chunk_size under 256");
|
||||
check(post("operation", "{}").status == 422, "operation needs op");
|
||||
check(post("operation", "{\"op\":\"nope\"}").status == 422, "unknown operation");
|
||||
check(post("operation", "{\"op\":\"files_api_routes_upload_file\"}").status == 422, "multipart operation refused");
|
||||
check(post("operation", "{\"op\":\"chat_completion_v1_chat_completions_post\",\"body\":{\"bogus\":1}}").status == 422,
|
||||
"unknown body field refused");
|
||||
|
||||
// dry runs: paid or resource-changing routes show the exact request
|
||||
auto dry = post("chat", "{\"prompt\":\"hi\"}");
|
||||
check(dry.status == 200 && contains(dry.body, "\"dry_run\":true") && contains(dry.body, "\"model\":\"mistral-small-latest\"") &&
|
||||
contains(dry.body, "/v1/chat/completions"),
|
||||
"chat is a dry run without confirm");
|
||||
check(contains(post("stream", "{\"prompt\":\"hi\"}").body, "\"stream\":true"), "stream preview");
|
||||
check(contains(post("agent", "{\"agent_id\":\"ag_1\",\"prompt\":\"hi\"}").body, "/v1/agents/completions"), "agent preview");
|
||||
check(contains(post("fim", "{\"prompt\":\"def f():\"}").body, "/v1/fim/completions"), "fim preview");
|
||||
check(contains(post("embeddings", "{\"input\":\"x\"}").body, "\"model\":\"mistral-embed\""), "embeddings preview");
|
||||
check(contains(post("moderation", "{\"input\":\"x\"}").body, "\"dry_run\":true"), "moderation is a dry run");
|
||||
check(contains(post("ocr", "{\"reference\":\"https://x.test/a.pdf\"}").body, "mistral-ocr-latest"), "ocr preview");
|
||||
check(contains(post("transcribe", "{\"file_url\":\"https://x.test/a.mp3\"}").body, "voxtral-mini-latest"), "transcribe preview");
|
||||
check(contains(post("files", "{\"action\":\"delete\",\"id\":\"f1\"}").body, "\"dry_run\":true"), "file delete is a dry run");
|
||||
check(contains(post("files", "{\"action\":\"upload\",\"filename\":\"a.jsonl\",\"data_base64\":\"aGVsbG8=\"}").body, "\"bytes\":5"),
|
||||
"upload is a dry run");
|
||||
check(contains(post("batch", "{\"action\":\"create\",\"model\":\"m\",\"input_files\":[\"f1\"]}").body, "/v1/batch/jobs"), "batch create preview");
|
||||
check(contains(post("batch", "{\"action\":\"cancel\",\"id\":\"b1\"}").body, "\"dry_run\":true"), "batch cancel is a dry run");
|
||||
check(contains(post("finetune", "{\"action\":\"create\",\"model\":\"open-mistral-7b\",\"training_files\":[\"f1\"],\"hyperparameters\":{\"training_steps\":10}}").body,
|
||||
"\"dry_run\":true"),
|
||||
"finetune create is a dry run");
|
||||
check(contains(post("agents", "{\"action\":\"delete\",\"id\":\"ag_1\"}").body, "\"dry_run\":true"), "agent delete is a dry run");
|
||||
check(contains(post("conversations", "{\"action\":\"start\",\"prompt\":\"hi\"}").body, "\"dry_run\":true"), "conversation start is a dry run");
|
||||
check(contains(post("libraries", "{\"action\":\"delete\",\"id\":\"lib_1\"}").body, "\"dry_run\":true"), "library delete is a dry run");
|
||||
check(contains(post("operation", "{\"op\":\"files_api_routes_delete_file\",\"ids\":[\"f1\"]}").body, "\"dry_run\":true"),
|
||||
"destructive operation is a dry run");
|
||||
check(contains(post("operation", "{\"op\":\"files_api_routes_delete_file\",\"ids\":[\"f1\"]}").body, "/v1/files/f1"),
|
||||
"operation preview renders the path");
|
||||
|
||||
// 503: free calls and confirmed calls need the credential
|
||||
check(post("models", "{}").status == 503 && contains(post("models", "{}").body, "mistral_not_configured"), "models without key is 503");
|
||||
check(post("files", "{\"action\":\"list\"}").status == 503, "files list without key is 503");
|
||||
check(post("files", "{\"action\":\"get\",\"id\":\"f1\"}").status == 503, "files get without key is 503");
|
||||
check(post("batch", "{\"action\":\"list\"}").status == 503, "batch list without key is 503");
|
||||
check(post("finetune", "{\"action\":\"list\"}").status == 503, "finetune list without key is 503");
|
||||
check(post("agents", "{\"action\":\"list\"}").status == 503, "agents list without key is 503");
|
||||
check(post("conversations", "{\"action\":\"list\"}").status == 503, "conversations list without key is 503");
|
||||
check(post("libraries", "{\"action\":\"list\"}").status == 503, "libraries list without key is 503");
|
||||
check(post("operation", "{\"op\":\"list_models_v1_models_get\"}").status == 503, "read operation without key is 503");
|
||||
check(post("chat", "{\"prompt\":\"hi\",\"confirm\":true}").status == 503, "confirmed chat without key is 503");
|
||||
check(post("stream", "{\"prompt\":\"hi\",\"confirm\":true}").status == 503, "confirmed stream without key is 503");
|
||||
check(post("embeddings", "{\"input\":\"x\",\"confirm\":true}").status == 503, "confirmed embeddings without key is 503");
|
||||
check(post("ocr", "{\"reference\":\"https://x.test/a.pdf\",\"confirm\":true}").status == 503, "confirmed ocr without key is 503");
|
||||
check(post("files", "{\"action\":\"delete\",\"id\":\"f1\",\"confirm\":true}").status == 503, "confirmed delete without key is 503");
|
||||
return finish("ai/mistral/routes");
|
||||
}
|
||||
Vendored
+60
@@ -0,0 +1,60 @@
|
||||
#pragma once
|
||||
|
||||
// Shared rig for the Mistral tests: a Platform over one MockTransport and a
|
||||
// fake key. The mock only records the requests the real client builds; replies
|
||||
// are documents taken verbatim from docs.mistral.ai/openapi.yaml examples
|
||||
// (labelled FIXTURE) or, where the spec has no example, a body in the shape of
|
||||
// the spec schema with invented values (labelled SHAPE). Nothing here verifies
|
||||
// vendor behavior (see src/vendors/mistral/SPEC.md ## Unverified).
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "clients/transports/mock_transport.h"
|
||||
#include "framework.h"
|
||||
#include "vendors/mistral/platform.h"
|
||||
|
||||
namespace mistral_test {
|
||||
|
||||
using molo::clients::ClientResponse;
|
||||
using molo::clients::HeaderMap;
|
||||
using molo::clients::Method;
|
||||
using molo::clients::transports::MockExpectation;
|
||||
using molo::clients::transports::MockTransport;
|
||||
using Json = molo::clients::body::Json;
|
||||
|
||||
inline ClientResponse reply(const std::string& body, int status = 200,
|
||||
const std::string& type = "application/json") {
|
||||
HeaderMap h;
|
||||
h.set("Content-Type", type);
|
||||
return ClientResponse(status, h, body);
|
||||
}
|
||||
|
||||
inline ClientResponse sse(const std::string& body) { return reply(body, 200, "text/event-stream"); }
|
||||
|
||||
inline bool has(const std::string& hay, const std::string& needle) { return hay.find(needle) != std::string::npos; }
|
||||
|
||||
inline const char* kKey = "mistral-TESTKEY-DO-NOT-LEAK";
|
||||
|
||||
struct Rig {
|
||||
MockTransport* transport = nullptr;
|
||||
molo::mistral::Platform platform;
|
||||
|
||||
explicit Rig(const std::string& key = kKey) {
|
||||
auto t = std::make_unique<MockTransport>();
|
||||
transport = t.get();
|
||||
platform = molo::mistral::Platform::with(std::move(t), key);
|
||||
}
|
||||
std::shared_ptr<molo::llm::ApiClient> client() const { return platform.client; }
|
||||
void on(Method m, const std::string& path, ClientResponse r, int times = 1) {
|
||||
MockExpectation e;
|
||||
e.method = m;
|
||||
e.path = path;
|
||||
e.response = std::move(r);
|
||||
e.times = times;
|
||||
transport->expect(e);
|
||||
}
|
||||
MockTransport::SeenRequest last() const { return transport->seen().back(); }
|
||||
};
|
||||
|
||||
} // namespace mistral_test
|
||||
+319
@@ -0,0 +1,319 @@
|
||||
// Agents, conversations (including the SSE stream), libraries and the generic
|
||||
// Operations caller. Replies are SHAPE fixtures read from the spec schemas
|
||||
// (Agent, ConversationResponse, ConversationEvents, Library, Document), values
|
||||
// invented: the platform never answered with these.
|
||||
#include "support.h"
|
||||
#include "vendors/mistral/agents.h"
|
||||
#include "vendors/mistral/conversations.h"
|
||||
#include "vendors/mistral/libraries.h"
|
||||
#include "vendors/mistral/operations.h"
|
||||
|
||||
using namespace molo::mistral;
|
||||
using namespace mistral_test;
|
||||
using molo::llm::ApiError;
|
||||
|
||||
namespace {
|
||||
const char* kAgent =
|
||||
"{\"id\":\"ag_1\",\"object\":\"agent\",\"name\":\"helper\",\"model\":\"mistral-medium-latest\",\"version\":2,\"versions\":[1,2],"
|
||||
"\"created_at\":\"2026-01-01T00:00:00Z\",\"updated_at\":\"2026-01-02T00:00:00Z\",\"deployment_chat\":false,\"source\":\"api\"}";
|
||||
const char* kConv =
|
||||
"{\"object\":\"conversation.response\",\"conversation_id\":\"conv_1\",\"outputs\":[{\"object\":\"entry\",\"type\":\"message.output\","
|
||||
"\"role\":\"assistant\",\"content\":\"Hi there\"},{\"type\":\"message.output\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"!\"}]}],"
|
||||
"\"usage\":{\"prompt_tokens\":3,\"completion_tokens\":4,\"total_tokens\":7}}";
|
||||
const char* kConvStream =
|
||||
"event: conversation.response.started\ndata: {\"type\":\"conversation.response.started\",\"conversation_id\":\"conv_1\"}\n\n"
|
||||
"event: message.output.delta\ndata: {\"type\":\"message.output.delta\",\"content\":\"Hi \",\"output_index\":0}\n\n"
|
||||
": keep-alive\n\n"
|
||||
"event: message.output.delta\ndata: {\"type\":\"message.output.delta\",\"content\":\"there\",\"output_index\":0}\n\n"
|
||||
"event: conversation.response.done\ndata: {\"type\":\"conversation.response.done\",\"usage\":{\"prompt_tokens\":3,\"completion_tokens\":2,\"total_tokens\":5}}\n\n";
|
||||
const char* kLibrary =
|
||||
"{\"id\":\"lib_1\",\"name\":\"docs\",\"created_at\":\"2026-01-01T00:00:00Z\",\"updated_at\":\"2026-01-01T00:00:00Z\",\"owner_id\":\"o\","
|
||||
"\"owner_type\":\"User\",\"total_size\":10,\"nb_documents\":1,\"chunk_size\":1024}";
|
||||
const char* kDocument =
|
||||
"{\"id\":\"doc_1\",\"library_id\":\"lib_1\",\"name\":\"a.pdf\",\"mime_type\":\"application/pdf\",\"size\":99,\"process_status\":\"done\","
|
||||
"\"processing_status\":\"Done\",\"created_at\":\"2026-01-01T00:00:00Z\",\"number_of_pages\":3,\"tokens_processing_total\":0}";
|
||||
} // namespace
|
||||
|
||||
TEST(mistral_agents, crud_versions_aliases_and_validation) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/agents", reply(kAgent));
|
||||
rig.on(Method::kGet, "/v1/agents/pages", reply("{\"object\":\"list\",\"data\":[],\"next_page_token\":\"tok\"}"));
|
||||
rig.on(Method::kGet, "/v1/agents/ag_1", reply(kAgent));
|
||||
rig.on(Method::kPatch, "/v1/agents/ag_1", reply(kAgent));
|
||||
rig.on(Method::kPatch, "/v1/agents/ag_1/version", reply(kAgent));
|
||||
rig.on(Method::kGet, "/v1/agents/ag_1/versions", reply("[]"));
|
||||
rig.on(Method::kGet, "/v1/agents/ag_1/versions/1", reply(kAgent));
|
||||
rig.on(Method::kPut, "/v1/agents/ag_1/aliases", reply("{\"alias\":\"prod\",\"version\":2}"));
|
||||
rig.on(Method::kDelete, "/v1/agents/ag_1/aliases", reply("", 204));
|
||||
rig.on(Method::kDelete, "/v1/agents/ag_1", reply("", 204));
|
||||
Agents ag(rig.client());
|
||||
AgentParams p;
|
||||
p.model = "mistral-medium-latest";
|
||||
p.name = "helper";
|
||||
p.instructions = "Be kind";
|
||||
p.tools = Json::parse("[{\"type\":\"web_search\"}]");
|
||||
AgentInfo a = ag.create(p);
|
||||
ASSERT_EQ(a.id, "ag_1");
|
||||
ASSERT_EQ(a.version, 2L);
|
||||
ASSERT_EQ(a.versions.size(), 2u);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"tools\":[{\"type\":\"web_search\"}]"));
|
||||
ASSERT_EQ(ag.list().next_page_token, "tok");
|
||||
ASSERT_EQ(ag.get("ag_1", 1).name, "helper");
|
||||
ASSERT_TRUE(has(rig.last().target, "agent_version=1"));
|
||||
AgentParams upd;
|
||||
upd.description = "new";
|
||||
ag.update("ag_1", upd);
|
||||
ASSERT_EQ(rig.last().body, "{\"description\":\"new\"}"); // PATCH sends only what is set
|
||||
ag.set_version("ag_1", 2);
|
||||
ASSERT_TRUE(has(rig.last().target, "version=2"));
|
||||
ASSERT_EQ(ag.versions("ag_1").items, 0u);
|
||||
ASSERT_EQ(ag.get_version("ag_1", 1).id, "ag_1");
|
||||
ag.set_alias("ag_1", "prod", 2);
|
||||
ASSERT_TRUE(has(rig.last().target, "alias=prod"));
|
||||
ag.remove_alias("ag_1", "prod");
|
||||
ag.remove("ag_1");
|
||||
AgentParams bad;
|
||||
ASSERT_THROW(ag.create(bad), ApiError);
|
||||
bad.model = "m";
|
||||
ASSERT_THROW(ag.create(bad), ApiError); // no name
|
||||
bad.name = "n";
|
||||
bad.tools = Json::parse("[{\"nope\":1}]");
|
||||
ASSERT_THROW(ag.create(bad), ApiError);
|
||||
ASSERT_THROW(ag.update("ag_1", AgentParams{}), ApiError); // nothing to update
|
||||
ASSERT_THROW(ag.get("a/b"), ApiError);
|
||||
ASSERT_THROW(ag.remove(""), ApiError);
|
||||
ASSERT_THROW(ag.set_alias("ag_1", "bad alias", 1), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_conversations, start_append_restart_and_reads) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/conversations", reply(kConv));
|
||||
rig.on(Method::kPost, "/v1/conversations/conv_1", reply(kConv));
|
||||
rig.on(Method::kPost, "/v1/conversations/conv_1/restart", reply(kConv));
|
||||
rig.on(Method::kGet, "/v1/conversations/conv_1", reply("{\"id\":\"conv_1\"}"));
|
||||
rig.on(Method::kGet, "/v1/conversations/conv_1/history", reply("{\"entries\":[]}"));
|
||||
rig.on(Method::kGet, "/v1/conversations/conv_1/messages", reply("{\"messages\":[]}"));
|
||||
rig.on(Method::kGet, "/v1/conversations", reply("[]"));
|
||||
rig.on(Method::kDelete, "/v1/conversations/conv_1", reply("", 204));
|
||||
Conversations c(rig.client());
|
||||
ConversationStartParams sp;
|
||||
sp.inputs = ConversationInput::text("hello");
|
||||
sp.agent_id = "ag_1";
|
||||
sp.store = false;
|
||||
ConversationResult r = c.start(sp);
|
||||
ASSERT_EQ(r.conversation_id, "conv_1");
|
||||
ASSERT_EQ(r.text(), "Hi there!");
|
||||
ASSERT_EQ(r.usage.total_tokens, 7);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"agent_id\":\"ag_1\""));
|
||||
ASSERT_TRUE(has(rig.last().body, "\"inputs\":\"hello\""));
|
||||
ASSERT_TRUE(has(rig.last().body, "\"store\":false"));
|
||||
ConversationAppendParams ap;
|
||||
ap.inputs = ConversationInput::entries({ConversationInput::user_entry("more")});
|
||||
c.append("conv_1", ap);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"role\":\"user\""));
|
||||
ConversationRestartParams rp;
|
||||
rp.from_entry_id = "entry_9";
|
||||
c.restart("conv_1", rp);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"from_entry_id\":\"entry_9\""));
|
||||
ASSERT_EQ(c.get("conv_1").find("id")->as_string(), "conv_1");
|
||||
c.history("conv_1");
|
||||
c.messages("conv_1");
|
||||
ASSERT_EQ(c.list().items, 0u);
|
||||
c.remove("conv_1");
|
||||
// validation
|
||||
ConversationStartParams bad;
|
||||
bad.inputs = ConversationInput::text("x");
|
||||
ASSERT_THROW(c.start(bad), ApiError); // neither model nor agent
|
||||
bad.model = "m";
|
||||
bad.agent_id = "a";
|
||||
ASSERT_THROW(c.start(bad), ApiError); // both
|
||||
bad.agent_id.clear();
|
||||
bad.handoff_execution = "maybe";
|
||||
ASSERT_THROW(c.start(bad), ApiError);
|
||||
ASSERT_THROW(ConversationInput::text(""), ApiError);
|
||||
ASSERT_THROW(ConversationInput::entries({}), ApiError);
|
||||
ConversationRestartParams norp;
|
||||
ASSERT_THROW(c.restart("conv_1", norp), ApiError);
|
||||
ASSERT_THROW(c.append("a/b", ap), ApiError);
|
||||
ASSERT_THROW(c.list(0, 101), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_conversations, stream_events_fold_into_a_result) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/conversations", sse(kConvStream));
|
||||
Conversations c(rig.client());
|
||||
ConversationStartParams sp;
|
||||
sp.inputs = ConversationInput::text("hello");
|
||||
sp.model = "mistral-medium-latest";
|
||||
std::vector<std::string> names;
|
||||
ConversationResult r = c.start_stream(sp, [&](const ConversationEvent& e) {
|
||||
names.push_back(e.event);
|
||||
return true;
|
||||
});
|
||||
ASSERT_EQ(r.conversation_id, "conv_1");
|
||||
ASSERT_EQ(r.text(), "Hi there");
|
||||
ASSERT_EQ(r.usage.total_tokens, 5);
|
||||
ASSERT_EQ(names.size(), 4u);
|
||||
ASSERT_EQ(names[1], "message.output.delta");
|
||||
ASSERT_TRUE(has(rig.last().body, "\"stream\":true"));
|
||||
}
|
||||
|
||||
TEST(mistral_conversations, truncated_error_and_early_stop) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/conversations", sse("event: message.output.delta\ndata: {\"content\":\"x\"}\n\n"));
|
||||
rig.on(Method::kPost, "/v1/conversations/c1", sse("event: conversation.response.error\ndata: {\"message\":\"boom\",\"code\":500}\n\n"));
|
||||
rig.on(Method::kPost, "/v1/conversations", sse(kConvStream));
|
||||
Conversations c(rig.client());
|
||||
ConversationStartParams sp;
|
||||
sp.inputs = ConversationInput::text("hello");
|
||||
sp.model = "m";
|
||||
try {
|
||||
c.start_stream(sp, nullptr);
|
||||
FAIL("expected STREAM_TRUNCATED");
|
||||
} catch (const ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "STREAM_TRUNCATED");
|
||||
}
|
||||
ConversationAppendParams ap;
|
||||
ap.inputs = ConversationInput::text("more");
|
||||
try {
|
||||
c.append_stream("c1", ap, nullptr);
|
||||
FAIL("expected STREAM_ERROR");
|
||||
} catch (const ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "STREAM_ERROR");
|
||||
ASSERT_EQ(e.message(), "boom");
|
||||
}
|
||||
ConversationResult stopped = c.start_stream(sp, [](const ConversationEvent& e) { return e.event != "message.output.delta"; });
|
||||
ASSERT_EQ(stopped.conversation_id, "conv_1"); // stopped by the sink: no truncation error
|
||||
}
|
||||
|
||||
TEST(mistral_libraries, libraries_documents_and_sharing) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/libraries", reply(kLibrary, 201));
|
||||
rig.on(Method::kGet, "/v1/libraries", reply("{\"data\":[],\"next_page_token\":null}"));
|
||||
rig.on(Method::kGet, "/v1/libraries/lib_1", reply(kLibrary));
|
||||
rig.on(Method::kPatch, "/v1/libraries/lib_1", reply(kLibrary));
|
||||
rig.on(Method::kDelete, "/v1/libraries/lib_1", reply(kLibrary));
|
||||
rig.on(Method::kPost, "/v1/libraries/lib_1/documents", reply(kDocument, 201));
|
||||
rig.on(Method::kGet, "/v1/libraries/lib_1/documents", reply("{\"pagination\":{},\"data\":[]}"));
|
||||
rig.on(Method::kGet, "/v1/libraries/lib_1/documents/doc_1", reply(kDocument));
|
||||
rig.on(Method::kPatch, "/v1/libraries/lib_1/documents/doc_1", reply(kDocument));
|
||||
rig.on(Method::kDelete, "/v1/libraries/lib_1/documents/doc_1", reply("", 204));
|
||||
rig.on(Method::kGet, "/v1/libraries/lib_1/documents/doc_1/signed-url", reply("\"https://signed.example/d\""));
|
||||
rig.on(Method::kGet, "/v1/libraries/lib_1/documents/doc_1/text_content", reply("{\"text\":\"abc\"}"));
|
||||
rig.on(Method::kPost, "/v1/libraries/lib_1/documents/doc_1/reprocess", reply("", 204));
|
||||
rig.on(Method::kPut, "/v1/libraries/lib_1/share", reply("{\"library_id\":\"lib_1\"}"));
|
||||
rig.on(Method::kDelete, "/v1/libraries/lib_1/share", reply("{\"library_id\":\"lib_1\"}"));
|
||||
Libraries l(rig.client());
|
||||
LibraryCreateParams cp;
|
||||
cp.name = "docs";
|
||||
cp.chunk_size = 1024;
|
||||
LibraryInfo lib = l.create(cp);
|
||||
ASSERT_EQ(lib.id, "lib_1");
|
||||
ASSERT_EQ(lib.nb_documents, 1L);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"chunk_size\":1024"));
|
||||
ASSERT_EQ(l.list().items, 0u);
|
||||
ASSERT_EQ(l.get("lib_1").name, "docs");
|
||||
l.update("lib_1", "renamed", "");
|
||||
ASSERT_EQ(rig.last().body, "{\"name\":\"renamed\"}");
|
||||
DocumentUploadParams up;
|
||||
up.filename = "a.pdf";
|
||||
up.data = "%PDF-1.4";
|
||||
DocumentInfo d = l.upload_document("lib_1", up);
|
||||
ASSERT_EQ(d.id, "doc_1");
|
||||
ASSERT_TRUE(d.processed());
|
||||
ASSERT_EQ(d.number_of_pages, 3L);
|
||||
ASSERT_TRUE(has(rig.last().headers.get_or("Content-Type", ""), "multipart/form-data"));
|
||||
ASSERT_EQ(l.documents("lib_1").items, 0u);
|
||||
ASSERT_EQ(l.document("lib_1", "doc_1").name, "a.pdf");
|
||||
l.update_document("lib_1", "doc_1", "b.pdf");
|
||||
ASSERT_EQ(l.document_signed_url("lib_1", "doc_1"), "https://signed.example/d");
|
||||
ASSERT_EQ(l.document_text("lib_1", "doc_1", 0, 1).find("text")->as_string(), "abc");
|
||||
ASSERT_TRUE(has(rig.last().target, "page_start=0"));
|
||||
l.reprocess_document("lib_1", "doc_1");
|
||||
l.remove_document("lib_1", "doc_1");
|
||||
l.share("lib_1", "Viewer", "u1", "User");
|
||||
ASSERT_TRUE(has(rig.last().body, "\"level\":\"Viewer\""));
|
||||
l.unshare("lib_1", "u1", "User");
|
||||
ASSERT_TRUE(has(rig.last().body, "\"share_with_uuid\":\"u1\""));
|
||||
l.remove("lib_1");
|
||||
LibraryCreateParams bad;
|
||||
ASSERT_THROW(l.create(bad), ApiError);
|
||||
bad.name = "n";
|
||||
bad.chunk_size = 255;
|
||||
ASSERT_THROW(l.create(bad), ApiError);
|
||||
bad.chunk_size = 32769;
|
||||
ASSERT_THROW(l.create(bad), ApiError);
|
||||
DocumentUploadParams noup;
|
||||
ASSERT_THROW(l.upload_document("lib_1", noup), ApiError);
|
||||
ASSERT_THROW(l.share("lib_1", "Owner", "u1", "User"), ApiError);
|
||||
ASSERT_THROW(l.share("lib_1", "Viewer", "u 1", "User"), ApiError);
|
||||
ASSERT_THROW(l.document("lib_1", "../x"), ApiError);
|
||||
ASSERT_THROW(l.update("lib_1", "", ""), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_operations, any_json_operation_is_checked_against_the_table) {
|
||||
Rig rig;
|
||||
rig.on(Method::kGet, "/v1/workflows/executions/ex1", reply("{\"id\":\"ex1\"}"));
|
||||
rig.on(Method::kPost, "/v1/models", reply("{}")); // never reached
|
||||
Operations ops(rig.client());
|
||||
// a workflow read through the generic caller
|
||||
Invocation read;
|
||||
read.op = "get_workflow_execution_v1_workflows_executions__execution_id__get";
|
||||
if (!Calls::try_find(read.op)) {
|
||||
// find the operation by path instead of trusting a guessed id
|
||||
for (std::size_t i = 0; i < Calls::count(); ++i)
|
||||
if (std::string(Calls::at(i).path) == "/v1/workflows/executions/{execution_id}" &&
|
||||
std::string(Calls::at(i).http_method) == "GET")
|
||||
read.op = Calls::at(i).op;
|
||||
}
|
||||
read.ids = {"ex1"};
|
||||
ASSERT_EQ(ops.invoke(read).find("id")->as_string(), "ex1");
|
||||
ASSERT_EQ(rig.last().method, "GET");
|
||||
|
||||
// wrong id count, bad id, unknown query, unknown body field, body on a bodiless op
|
||||
Invocation bad = read;
|
||||
bad.ids = {};
|
||||
ASSERT_THROW(Operations::check(bad), ApiError);
|
||||
bad.ids = {"a/b"};
|
||||
ASSERT_THROW(ops.invoke(bad), ApiError);
|
||||
bad = read;
|
||||
bad.query["nope"] = "1";
|
||||
ASSERT_THROW(Operations::check(bad), ApiError);
|
||||
bad = read;
|
||||
bad.body = Json::object();
|
||||
ASSERT_THROW(Operations::check(bad), ApiError);
|
||||
Invocation chat;
|
||||
chat.op = "chat_completion_v1_chat_completions_post";
|
||||
chat.body.set("not_a_field", Json(1));
|
||||
ASSERT_THROW(Operations::check(chat), ApiError);
|
||||
chat.body = Json::object();
|
||||
chat.body.set("model", Json("m"));
|
||||
Operations::check(chat); // fits the row
|
||||
ASSERT_THROW(Operations::check(Invocation{"unknown_op", {}, {}, Json(), false}), ApiError);
|
||||
// multipart, streaming and binary rows are refused
|
||||
Invocation up;
|
||||
up.op = "files_api_routes_upload_file";
|
||||
ASSERT_THROW(Operations::check(up), ApiError);
|
||||
up.op = "files_api_routes_download_file";
|
||||
up.ids = {"f1"};
|
||||
ASSERT_THROW(Operations::check(up), ApiError);
|
||||
up.op = "agents_api_v1_conversations_start_stream";
|
||||
up.ids = {};
|
||||
ASSERT_THROW(Operations::check(up), ApiError);
|
||||
// destructive rows need the explicit flag
|
||||
Invocation del;
|
||||
del.op = "files_api_routes_delete_file";
|
||||
del.ids = {"f1"};
|
||||
ASSERT_THROW(Operations::check(del), ApiError);
|
||||
del.allow_destructive = true;
|
||||
Operations::check(del);
|
||||
ASSERT_EQ(rig.transport->send_count(), 1u); // only the first invoke went out
|
||||
}
|
||||
|
||||
TEST(mistral_operations, catalog_lists_areas_and_operations) {
|
||||
std::vector<std::string> areas = Operations::areas();
|
||||
ASSERT_TRUE(areas.size() > 20);
|
||||
ASSERT_EQ(Operations::list().size(), Calls::count());
|
||||
ASSERT_EQ(Operations::list("chat").size(), 1u);
|
||||
ASSERT_EQ(Operations::list("no-such-area").size(), 0u);
|
||||
}
|
||||
+168
@@ -0,0 +1,168 @@
|
||||
// The call table: every row well formed, every Op constant present, paths
|
||||
// render only with valid ids, and every typed request body uses only fields the
|
||||
// table row declares (the table is proven against the OpenAPI documents by
|
||||
// tools/check_spec.py).
|
||||
#include <set>
|
||||
|
||||
#include "support.h"
|
||||
#include "vendors/mistral/agents.h"
|
||||
#include "vendors/mistral/batch.h"
|
||||
#include "vendors/mistral/calls.h"
|
||||
#include "vendors/mistral/chat.h"
|
||||
#include "vendors/mistral/conversations.h"
|
||||
#include "vendors/mistral/embeddings.h"
|
||||
#include "vendors/mistral/finetune.h"
|
||||
#include "vendors/mistral/ocr.h"
|
||||
#include "vendors/mistral/ops.h"
|
||||
#include "vendors/mistral/audio.h"
|
||||
|
||||
using namespace molo::mistral;
|
||||
using namespace mistral_test;
|
||||
using molo::llm::ApiError;
|
||||
|
||||
TEST(mistral_calls, table_rows_are_well_formed_and_unique) {
|
||||
std::set<std::string> ops, keys;
|
||||
std::size_t sources_docs = 0, sources_pd = 0;
|
||||
for (std::size_t i = 0; i < Calls::count(); ++i) {
|
||||
const CallSpec& s = Calls::at(i);
|
||||
ASSERT_TRUE(ops.insert(s.op).second);
|
||||
ASSERT_TRUE(keys.insert(std::string(s.http_method) + " " + s.path).second);
|
||||
ASSERT_TRUE(std::string(s.path).rfind("/v", 0) == 0);
|
||||
std::string m = s.http_method;
|
||||
ASSERT_TRUE(m == "GET" || m == "POST" || m == "PUT" || m == "PATCH" || m == "DELETE");
|
||||
std::string src = s.source;
|
||||
ASSERT_TRUE(src == "docs" || src == "pd");
|
||||
(src == "docs" ? sources_docs : sources_pd)++;
|
||||
std::string rk = s.request;
|
||||
ASSERT_TRUE(rk == "none" || rk == "json" || rk == "multipart");
|
||||
std::string rs = s.response_kind;
|
||||
ASSERT_TRUE(rs == "none" || rs == "json" || rs == "sse" || rs == "binary");
|
||||
if (rk == "none") ASSERT_EQ(std::string(s.body_fields), "");
|
||||
}
|
||||
ASSERT_EQ(sources_docs, 319u); // operations of docs.mistral.ai/openapi.yaml on 2026-10-25
|
||||
ASSERT_EQ(sources_pd, 28u); // extra operations only the platform-docs-public copy lists
|
||||
ASSERT_EQ(Calls::count(), 347u);
|
||||
}
|
||||
|
||||
TEST(mistral_calls, every_op_constant_is_a_table_row) {
|
||||
for (const char* op : {Op::kChat, Op::kFim, Op::kAgentsCompletion, Op::kEmbeddings, Op::kModerations,
|
||||
Op::kChatModerations, Op::kClassifications, Op::kChatClassifications, Op::kOcr,
|
||||
Op::kTranscribe, Op::kSpeech, Op::kVoicesList, Op::kVoicesListV1, Op::kVoiceCreate,
|
||||
Op::kVoiceGet, Op::kVoiceUpdate, Op::kVoiceDelete, Op::kVoiceSample, Op::kModelsList,
|
||||
Op::kModelGet, Op::kModelDelete, Op::kFileUpload, Op::kFileList, Op::kFileGet,
|
||||
Op::kFileDelete, Op::kFileContent, Op::kFileUrl, Op::kFtJobList, Op::kFtJobCreate,
|
||||
Op::kFtJobGet, Op::kFtJobStart, Op::kFtJobCancel, Op::kFtModelUpdate, Op::kFtModelArchive,
|
||||
Op::kFtModelUnarchive, Op::kBatchList, Op::kBatchCreate, Op::kBatchGet, Op::kBatchCancel,
|
||||
Op::kBatchDelete, Op::kAgentCreate, Op::kAgentListPages, Op::kAgentGet, Op::kAgentUpdate,
|
||||
Op::kAgentDelete, Op::kAgentSetVersion, Op::kAgentVersions, Op::kAgentVersionGet,
|
||||
Op::kAgentAliasSet, Op::kAgentAliasList, Op::kAgentAliasDelete, Op::kConvStart,
|
||||
Op::kConvStartStream, Op::kConvList, Op::kConvGet, Op::kConvDelete, Op::kConvAppend,
|
||||
Op::kConvAppendStream, Op::kConvHistory, Op::kConvMessages, Op::kConvRestart,
|
||||
Op::kConvRestartStream, Op::kLibList, Op::kLibCreate, Op::kLibGet, Op::kLibPatch,
|
||||
Op::kLibDelete, Op::kLibShareList, Op::kLibShareCreate, Op::kLibShareDelete, Op::kDocList,
|
||||
Op::kDocUpload, Op::kDocGet, Op::kDocPatch, Op::kDocDelete, Op::kDocText, Op::kDocStatus,
|
||||
Op::kDocSignedUrl, Op::kDocTextUrl, Op::kDocReprocess}) {
|
||||
ASSERT_TRUE(Calls::try_find(op) != nullptr);
|
||||
}
|
||||
ASSERT_TRUE(Calls::try_find("no_such_operation") == nullptr);
|
||||
ASSERT_THROW(Calls::find("no_such_operation"), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_calls, render_validates_ids_and_counts) {
|
||||
ASSERT_EQ(Calls::render(Op::kFileGet, {"abc-123"}), "/v1/files/abc-123");
|
||||
ASSERT_EQ(Calls::render(Op::kDocGet, {"lib1", "doc2"}), "/v1/libraries/lib1/documents/doc2");
|
||||
ASSERT_EQ(Calls::render(Op::kConvStartStream), "/v1/conversations"); // "#stream" is spec-only
|
||||
ASSERT_EQ(Calls::render(Op::kConvAppendStream, {"c1"}), "/v1/conversations/c1");
|
||||
ASSERT_EQ(Calls::render(Op::kModelGet, {"ft:open-mistral-7b:a:2024:b"}), "/v1/models/ft:open-mistral-7b:a:2024:b");
|
||||
ASSERT_THROW(Calls::render(Op::kFileGet, {"../x"}), ApiError);
|
||||
ASSERT_THROW(Calls::render(Op::kFileGet, {"a/b"}), ApiError);
|
||||
ASSERT_THROW(Calls::render(Op::kFileGet, {""}), ApiError);
|
||||
ASSERT_THROW(Calls::render(Op::kFileGet, {}), ApiError);
|
||||
ASSERT_THROW(Calls::render(Op::kFileGet, {"a", "b"}), ApiError);
|
||||
ASSERT_THROW(Calls::render(Op::kChat, {"a"}), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_calls, destructive_rows_are_recognised) {
|
||||
ASSERT_TRUE(Calls::is_destructive(Calls::find(Op::kFileDelete)));
|
||||
ASSERT_TRUE(Calls::is_destructive(Calls::find(Op::kBatchCancel)));
|
||||
ASSERT_TRUE(Calls::is_destructive(Calls::find(Op::kFtJobCancel)));
|
||||
ASSERT_TRUE(Calls::is_destructive(Calls::find(Op::kFtModelArchive)));
|
||||
ASSERT_TRUE(Calls::is_destructive(Calls::find(Op::kConvDelete)));
|
||||
ASSERT_FALSE(Calls::is_destructive(Calls::find(Op::kChat)));
|
||||
ASSERT_FALSE(Calls::is_destructive(Calls::find(Op::kFileGet)));
|
||||
}
|
||||
|
||||
namespace {
|
||||
void all_fields_declared(const Json& body, const char* op) {
|
||||
const CallSpec& spec = Calls::find(op);
|
||||
for (const auto& [k, v] : body.as_object()) {
|
||||
if (!Calls::has_body_field(spec, k)) FAIL(std::string(op) + " body field not in the table: " + k);
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(mistral_calls, typed_request_bodies_only_use_declared_fields) {
|
||||
// Every optional field set at once.
|
||||
ChatParams p = ChatParams::prompt("hi");
|
||||
p.temperature = 0.5; p.top_p = 0.9; p.presence_penalty = 0.1; p.frequency_penalty = 0.1;
|
||||
p.repetition_penalty = 1.0; p.max_tokens = 5; p.min_tokens = 1; p.random_seed = 3; p.top_k = 4; p.n = 2;
|
||||
p.top_logprobs = 3; p.logprobs = true; p.safe_prompt = true; p.parallel_tool_calls = true;
|
||||
p.stop = {"x"};
|
||||
ToolDef t; t.name = "f"; p.tools.push_back(t);
|
||||
p.tool_choice = "f"; p.format = ResponseFormat::kJsonSchema; p.schema_name = "s";
|
||||
p.reasoning_effort = "high"; p.prompt_mode = "reasoning"; p.prompt_cache_key = "k"; p.service_tier = "auto";
|
||||
p.prediction = "guess"; p.metadata = Json::object(); p.guardrails = Json::array();
|
||||
all_fields_declared(p.to_json(true), Op::kChat);
|
||||
|
||||
ChatParams a = p;
|
||||
a.agent_id = "ag_1"; a.temperature.reset(); a.top_p.reset(); a.safe_prompt.reset();
|
||||
all_fields_declared(a.to_json(true), Op::kAgentsCompletion);
|
||||
ASSERT_TRUE(a.to_json().find("model") == nullptr);
|
||||
|
||||
FimParams f; f.prompt = "a"; f.suffix = "b"; f.temperature = 1; f.top_p = 1; f.max_tokens = 1; f.min_tokens = 1;
|
||||
f.random_seed = 1; f.stop = {"s"}; f.prompt_cache_key = "k"; f.metadata = Json::object();
|
||||
all_fields_declared(f.to_json(true), Op::kFim);
|
||||
|
||||
EmbeddingParams e; e.inputs = {"a", "b"}; e.output_dimension = 8; e.output_dtype = "int8"; e.encoding_format = "float";
|
||||
all_fields_declared(e.to_json(), Op::kEmbeddings);
|
||||
|
||||
OcrParams o; o.reference = "https://x.test/a.pdf"; o.pages = {0}; o.include_image_base64 = true; o.image_limit = 1;
|
||||
o.image_min_size = 1; o.table_format = "html"; o.extract_header = true; o.extract_footer = true;
|
||||
o.include_blocks = true; o.confidence_scores_granularity = "page"; o.document_annotation_prompt = "p";
|
||||
o.document_annotation_format = Json::object(); o.bbox_annotation_format = Json::object();
|
||||
all_fields_declared(o.to_json(), Op::kOcr);
|
||||
|
||||
BatchParams b; b.model = "m"; b.requests.push_back({"c", Json::object()}); b.metadata = Json::object(); b.timeout_hours = 5;
|
||||
all_fields_declared(b.to_json(), Op::kBatchCreate);
|
||||
|
||||
FineTuneJobParams j; j.model = "open-mistral-7b"; j.training_files.push_back({"f1", 1.0}); j.validation_files = {"f2"};
|
||||
j.suffix = "s"; j.job_type = "completion"; j.hyperparameters.set("learning_rate", Json(0.0001));
|
||||
j.integrations = Json::array(); j.repositories = Json::array(); j.classifier_targets = Json::array();
|
||||
j.auto_start = true; j.invalid_sample_skip_percentage = 0.5;
|
||||
all_fields_declared(j.to_json(), Op::kFtJobCreate);
|
||||
|
||||
AgentParams ag; ag.model = "m"; ag.name = "n"; ag.instructions = "i"; ag.description = "d";
|
||||
ag.tools = Json::array(); ag.completion_args = Json::object(); ag.guardrails = Json::array();
|
||||
ag.metadata = Json::object(); ag.handoffs = {"a1"}; ag.version_message = "v";
|
||||
all_fields_declared(ag.to_json(true), Op::kAgentCreate);
|
||||
all_fields_declared(ag.to_json(false), Op::kAgentUpdate);
|
||||
|
||||
ConversationStartParams c; c.inputs = ConversationInput::text("hi"); c.agent_id = "a"; c.agent_version = 2;
|
||||
c.instructions = "i"; c.name = "n"; c.description = "d"; c.tools = Json::array(); c.completion_args = Json::object();
|
||||
c.guardrails = Json::array(); c.metadata = Json::object(); c.store = true; c.handoff_execution = "server";
|
||||
all_fields_declared(c.to_json(true), Op::kConvStart);
|
||||
all_fields_declared(c.to_json(true), Op::kConvStartStream);
|
||||
ConversationAppendParams ca; ca.inputs = ConversationInput::text("hi"); ca.completion_args = Json::object();
|
||||
ca.tool_confirmations = Json::array(); ca.store = true; ca.handoff_execution = "client";
|
||||
all_fields_declared(ca.to_json(true), Op::kConvAppend);
|
||||
ConversationRestartParams cr; cr.from_entry_id = "e1"; cr.inputs = ConversationInput::text("x");
|
||||
cr.completion_args = Json::object(); cr.metadata = Json::object(); cr.store = false; cr.handoff_execution = "client";
|
||||
cr.agent_version = 1;
|
||||
all_fields_declared(cr.to_json(true), Op::kConvRestart);
|
||||
|
||||
SpeechParams sp; sp.model = "m"; sp.input = "hello"; sp.voice_id = "v1"; sp.response_format = "wav";
|
||||
all_fields_declared(sp.to_json(), Op::kSpeech);
|
||||
VoiceCreateParams vc; vc.name = "n"; vc.slug = "s"; vc.languages = {"en"}; vc.gender = "g"; vc.description = "d";
|
||||
vc.age = 30; vc.tags = {"t"}; vc.sample_audio = "AAAA"; vc.sample_filename = "a.wav";
|
||||
all_fields_declared(vc.to_json(), Op::kVoiceCreate);
|
||||
}
|
||||
+340
@@ -0,0 +1,340 @@
|
||||
// Chat, agents and FIM completions plus MistralChatModel: request bodies,
|
||||
// validation before the network, parsing of replies, SSE streaming.
|
||||
//
|
||||
// FIXTURE: reply taken verbatim from docs.mistral.ai/openapi.yaml (the FIM
|
||||
// userExample, which is a ChatCompletionResponse).
|
||||
// SHAPE: shapes read from the spec schemas (ChatCompletionResponse,
|
||||
// CompletionChunk), values invented: Mistral's own stream was never seen.
|
||||
#include "support.h"
|
||||
#include "vendors/mistral/chat.h"
|
||||
#include "vendors/mistral/chat_model.h"
|
||||
|
||||
using namespace molo::mistral;
|
||||
using namespace mistral_test;
|
||||
using molo::llm::ApiError;
|
||||
|
||||
namespace {
|
||||
// FIXTURE: FIM userExample
|
||||
const char* kFim =
|
||||
"{\"id\": \"447e3e0d457e42e98248b5d2ef52a2a3\", \"object\": \"chat.completion\", \"model\": \"codestral-2508\", "
|
||||
"\"usage\": {\"prompt_tokens\": 8, \"completion_tokens\": 91, \"total_tokens\": 99}, \"created\": 1759496862, "
|
||||
"\"choices\": [{\"index\": 0, \"message\": {\"content\": \"add_numbers(a: int, b: int) -> int:\\n return a + b\\n\", "
|
||||
"\"tool_calls\": null, \"prefix\": false, \"role\": \"assistant\"}, \"finish_reason\": \"stop\"}]}";
|
||||
// SHAPE: ChatCompletionResponse with a tool call, thinking chunks and model_length
|
||||
const char* kToolReply =
|
||||
"{\"id\":\"c1\",\"object\":\"chat.completion\",\"model\":\"mistral-large-latest\",\"created\":1,"
|
||||
"\"usage\":{\"prompt_tokens\":5,\"completion_tokens\":7,\"total_tokens\":12},"
|
||||
"\"choices\":[{\"index\":0,\"finish_reason\":\"tool_calls\",\"message\":{\"role\":\"assistant\","
|
||||
"\"content\":[{\"type\":\"thinking\",\"thinking\":[{\"type\":\"text\",\"text\":\"need weather\"}]},{\"type\":\"text\",\"text\":\"Checking.\"}],"
|
||||
"\"tool_calls\":[{\"id\":\"D681PevKs\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}},"
|
||||
"{\"id\":\"X1\",\"type\":\"function\",\"function\":{\"name\":\"obj_args\",\"arguments\":{\"a\":1}}}]}}]}";
|
||||
// SHAPE: CompletionChunk stream, bare payloads then [DONE]
|
||||
const char* kStream =
|
||||
"data: {\"id\":\"s1\",\"object\":\"chat.completion.chunk\",\"created\":2,\"model\":\"mistral-small-latest\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"finish_reason\":null}]}\n\n"
|
||||
"data: {\"id\":\"s1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hel\"},\"finish_reason\":null}]}\n\n"
|
||||
": ping\n\n"
|
||||
"data: {\"id\":\"s1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"lo\"},\"finish_reason\":null}]}\n\n"
|
||||
"data: {\"id\":\"s1\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\"},\"finish_reason\":\"stop\"}],"
|
||||
"\"usage\":{\"prompt_tokens\":3,\"completion_tokens\":2,\"total_tokens\":5}}\n\n"
|
||||
"data: [DONE]\n\n";
|
||||
const char* kStreamTools =
|
||||
"data: {\"id\":\"s2\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"id\":\"t1\",\"index\":0,\"function\":{\"name\":\"f\",\"arguments\":\"{\\\"a\\\":\"}}]},\"finish_reason\":null}]}\n\n"
|
||||
"data: {\"id\":\"s2\",\"choices\":[{\"index\":0,\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"name\":\"\",\"arguments\":\"1}\"}}]},\"finish_reason\":\"tool_calls\"}]}\n\n"
|
||||
"data: [DONE]\n\n";
|
||||
} // namespace
|
||||
|
||||
TEST(mistral_chat, request_body_and_parse_of_the_documented_reply) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/fim/completions", reply(kFim));
|
||||
Fim fim(rig.client());
|
||||
FimParams p;
|
||||
p.prompt = "def ";
|
||||
p.suffix = "\n return a + b";
|
||||
p.max_tokens = 64;
|
||||
ChatResult r = fim.create(p);
|
||||
ASSERT_EQ(r.first().content, "add_numbers(a: int, b: int) -> int:\n return a + b\n");
|
||||
ASSERT_EQ(r.first().finish_reason, "stop");
|
||||
ASSERT_EQ(r.usage.total_tokens, 99);
|
||||
ASSERT_EQ(r.model, "codestral-2508");
|
||||
auto s = rig.last();
|
||||
ASSERT_TRUE(has(s.body, "\"model\":\"codestral-latest\""));
|
||||
ASSERT_TRUE(has(s.body, "\"suffix\":"));
|
||||
ASSERT_TRUE(has(s.body, "\"max_tokens\":64"));
|
||||
ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer ") + kKey);
|
||||
}
|
||||
|
||||
TEST(mistral_chat, chat_with_tools_thinking_and_object_arguments) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/chat/completions", reply(kToolReply));
|
||||
Chat chat(rig.client());
|
||||
ChatParams p = ChatParams::prompt("weather?");
|
||||
ToolDef t;
|
||||
t.name = "get_weather";
|
||||
t.description = "weather";
|
||||
t.parameters = Json::parse("{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}}}");
|
||||
p.tools.push_back(t);
|
||||
p.tool_choice = "any";
|
||||
ChatResult r = chat.create(p);
|
||||
const ChatChoice& c = r.first();
|
||||
ASSERT_EQ(c.content, "Checking.");
|
||||
ASSERT_EQ(c.reasoning, "need weather");
|
||||
ASSERT_EQ(c.tool_calls.size(), 2u);
|
||||
ASSERT_EQ(c.tool_calls[0].name, "get_weather");
|
||||
ASSERT_TRUE(c.tool_calls[0].arguments_valid());
|
||||
ASSERT_EQ(c.tool_calls[0].parsed().find("city")->as_string(), "Paris");
|
||||
ASSERT_EQ(c.tool_calls[1].arguments, "{\"a\":1}"); // object arguments are dumped to text
|
||||
ASSERT_EQ(c.finish_reason, "tool_calls");
|
||||
ASSERT_TRUE(c.history_message().find("tool_calls") != nullptr);
|
||||
auto s = rig.last();
|
||||
ASSERT_TRUE(has(s.body, "\"tool_choice\":\"any\""));
|
||||
ASSERT_TRUE(has(s.body, "\"type\":\"function\""));
|
||||
}
|
||||
|
||||
TEST(mistral_chat, named_tool_choice_and_json_schema_format) {
|
||||
ChatParams p = ChatParams::prompt("x");
|
||||
ToolDef t;
|
||||
t.name = "f";
|
||||
p.tools.push_back(t);
|
||||
p.tool_choice = "f";
|
||||
p.format = ResponseFormat::kJsonSchema;
|
||||
p.schema_name = "answer";
|
||||
p.schema = Json::parse("{\"type\":\"object\"}");
|
||||
p.schema_strict = true;
|
||||
std::string body = p.to_json().dump();
|
||||
ASSERT_TRUE(has(body, "\"tool_choice\":{\"function\":{\"name\":\"f\"},\"type\":\"function\"}"));
|
||||
ASSERT_TRUE(has(body, "\"response_format\":{\"json_schema\":{\"name\":\"answer\",\"schema\":{\"type\":\"object\"},\"strict\":true},\"type\":\"json_schema\"}"));
|
||||
}
|
||||
|
||||
TEST(mistral_chat, agents_completion_uses_agent_id_and_rejects_model_only_fields) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/agents/completions", reply(kFim));
|
||||
Chat chat(rig.client());
|
||||
ChatParams p = ChatParams::prompt("hi");
|
||||
p.agent_id = "ag_0123";
|
||||
ASSERT_EQ(chat.create(p).first().finish_reason, "stop");
|
||||
ASSERT_TRUE(has(rig.last().body, "\"agent_id\":\"ag_0123\""));
|
||||
ASSERT_FALSE(has(rig.last().body, "\"model\""));
|
||||
p.temperature = 0.2;
|
||||
ASSERT_THROW(chat.create(p), ApiError);
|
||||
p.temperature.reset();
|
||||
p.agent_id = "../x";
|
||||
ASSERT_THROW(chat.create(p), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_chat, invalid_input_never_reaches_the_network) {
|
||||
Rig rig;
|
||||
Chat chat(rig.client());
|
||||
ChatParams empty;
|
||||
ASSERT_THROW(chat.create(empty), ApiError);
|
||||
auto bad = [&](auto mutate) {
|
||||
ChatParams p = ChatParams::prompt("x");
|
||||
mutate(p);
|
||||
ASSERT_THROW(chat.create(p), ApiError);
|
||||
};
|
||||
bad([](ChatParams& p) { p.temperature = 1.6; });
|
||||
bad([](ChatParams& p) { p.temperature = -0.1; });
|
||||
bad([](ChatParams& p) { p.top_p = 0.0; });
|
||||
bad([](ChatParams& p) { p.top_p = 1.1; });
|
||||
bad([](ChatParams& p) { p.presence_penalty = 2.5; });
|
||||
bad([](ChatParams& p) { p.repetition_penalty = 0.0; });
|
||||
bad([](ChatParams& p) { p.max_tokens = -1; });
|
||||
bad([](ChatParams& p) { p.top_k = -2; });
|
||||
bad([](ChatParams& p) { p.n = 0; });
|
||||
bad([](ChatParams& p) { p.n = 17; });
|
||||
bad([](ChatParams& p) { p.model = "bad model!"; });
|
||||
bad([](ChatParams& p) { p.model = std::string(161, 'a'); });
|
||||
bad([](ChatParams& p) { p.stop = std::vector<std::string>(17, "x"); });
|
||||
bad([](ChatParams& p) { p.stop = {""}; });
|
||||
bad([](ChatParams& p) { p.reasoning_effort = "max"; });
|
||||
bad([](ChatParams& p) { p.service_tier = "gold"; });
|
||||
bad([](ChatParams& p) { p.prompt_mode = "fast"; });
|
||||
bad([](ChatParams& p) { p.tool_choice = "bad name!"; });
|
||||
bad([](ChatParams& p) { ToolDef t; t.name = "bad name"; p.tools.push_back(t); });
|
||||
bad([](ChatParams& p) { p.format = ResponseFormat::kJsonSchema; }); // no schema name
|
||||
bad([](ChatParams& p) { p.metadata = Json("not an object"); });
|
||||
bad([](ChatParams& p) { p.guardrails = Json::object(); });
|
||||
ASSERT_THROW(Messages::image_chunk("ftp://x"), ApiError);
|
||||
ASSERT_THROW(Messages::document_chunk("javascript:1"), ApiError);
|
||||
ASSERT_THROW(Messages::file_chunk("a/b"), ApiError);
|
||||
ASSERT_THROW(Messages::tool("", "n", "c"), ApiError);
|
||||
ASSERT_THROW(Messages::assistant_prefix(""), ApiError);
|
||||
ChatParams many = ChatParams::prompt("x");
|
||||
for (int i = 0; i < 4095; ++i) many.add(Messages::user("m"));
|
||||
ASSERT_THROW(many.add(Messages::user("one too many")), ApiError);
|
||||
ASSERT_EQ(rig.transport->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(mistral_chat, not_configured_has_no_traffic) {
|
||||
Rig rig("");
|
||||
Chat chat(rig.client());
|
||||
try {
|
||||
chat.create(ChatParams::prompt("hi"));
|
||||
FAIL("expected");
|
||||
} catch (const molo::llm::NotConfiguredError& e) {
|
||||
ASSERT_EQ(e.http_status(), 503);
|
||||
ASSERT_TRUE(has(e.message(), "MISTRAL_API_KEY"));
|
||||
}
|
||||
ASSERT_EQ(rig.transport->send_count(), 0u);
|
||||
ASSERT_FALSE(rig.platform.configured());
|
||||
}
|
||||
|
||||
TEST(mistral_chat, stream_transcript_comments_and_usage) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/chat/completions", sse(kStream));
|
||||
Chat chat(rig.client());
|
||||
std::string text;
|
||||
int deltas = 0;
|
||||
ChatResult r = chat.stream(ChatParams::prompt("Hi"), [&](const StreamDelta& d) {
|
||||
text += d.text;
|
||||
++deltas;
|
||||
return true;
|
||||
});
|
||||
ASSERT_EQ(text, "Hello");
|
||||
ASSERT_EQ(deltas, 4); // the ": ping" comment produces no event
|
||||
ASSERT_EQ(r.first().content, "Hello");
|
||||
ASSERT_EQ(r.first().finish_reason, "stop");
|
||||
ASSERT_EQ(r.id, "s1");
|
||||
ASSERT_EQ(r.model, "mistral-small-latest");
|
||||
ASSERT_EQ(r.usage.total_tokens, 5);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"stream\":true"));
|
||||
ASSERT_EQ(rig.last().headers.get_or("Accept", ""), "text/event-stream");
|
||||
}
|
||||
|
||||
TEST(mistral_chat, stream_merges_tool_call_fragments_and_stops_early) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/chat/completions", sse(kStreamTools));
|
||||
Chat chat(rig.client());
|
||||
ChatResult r = chat.stream(ChatParams::prompt("x"), nullptr);
|
||||
ASSERT_EQ(r.first().tool_calls.size(), 1u);
|
||||
ASSERT_EQ(r.first().tool_calls[0].id, "t1");
|
||||
ASSERT_EQ(r.first().tool_calls[0].name, "f");
|
||||
ASSERT_EQ(r.first().tool_calls[0].arguments, "{\"a\":1}");
|
||||
ASSERT_EQ(r.first().finish_reason, "tool_calls");
|
||||
|
||||
rig.on(Method::kPost, "/v1/chat/completions", sse(kStream));
|
||||
ChatResult early = chat.stream(ChatParams::prompt("x"), [](const StreamDelta& d) { return d.text != "Hel"; });
|
||||
ASSERT_EQ(early.first().content, "Hel"); // stopped by the sink: no truncation error
|
||||
}
|
||||
|
||||
TEST(mistral_chat, truncated_stream_is_loud) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/chat/completions",
|
||||
sse("data: {\"id\":\"s\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hel\"},\"finish_reason\":null}]}\n\n"));
|
||||
Chat chat(rig.client());
|
||||
try {
|
||||
chat.stream(ChatParams::prompt("x"), nullptr);
|
||||
FAIL("expected STREAM_TRUNCATED");
|
||||
} catch (const ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "STREAM_TRUNCATED");
|
||||
ASSERT_EQ(e.http_status(), 502);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(mistral_chat, spec_event_wrapper_is_unwrapped) {
|
||||
// The spec's CompletionEvent wraps the chunk as {"data": chunk}.
|
||||
ChatStreamAccumulator acc;
|
||||
acc.feed(Json::parse("{\"data\":{\"id\":\"w\",\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A\"},\"finish_reason\":\"stop\"}]}}"));
|
||||
ASSERT_TRUE(acc.done());
|
||||
ASSERT_EQ(acc.result().first().content, "A");
|
||||
ASSERT_EQ(acc.result().id, "w");
|
||||
}
|
||||
|
||||
TEST(mistral_chat, error_envelopes_map_to_api_error) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/chat/completions",
|
||||
reply("{\"object\":\"error\",\"message\":\"Unauthorized\",\"type\":\"invalid_request_error\",\"param\":null,\"code\":\"1100\"}", 401));
|
||||
Chat chat(rig.client());
|
||||
try {
|
||||
chat.create(ChatParams::prompt("x"));
|
||||
FAIL("expected 401");
|
||||
} catch (const ApiError& e) {
|
||||
ASSERT_EQ(e.http_status(), 401);
|
||||
ASSERT_EQ(e.type(), "invalid_request_error");
|
||||
ASSERT_EQ(e.message(), "Unauthorized");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(mistral_chatmodel, maps_a_neutral_request_to_wire_parameters) {
|
||||
Rig rig;
|
||||
MistralChatModel model(std::make_shared<Chat>(rig.client()));
|
||||
molo::llm::ChatRequest req;
|
||||
req.system = "be brief";
|
||||
req.messages.push_back(molo::llm::Message::user("hi"));
|
||||
molo::llm::Message a = molo::llm::Message::assistant("");
|
||||
molo::llm::ToolCall call;
|
||||
call.id = "c1";
|
||||
call.name = "f";
|
||||
call.arguments.set("x", Json(1));
|
||||
a.parts.push_back(molo::llm::ContentPart::of_call(call));
|
||||
req.messages.push_back(a);
|
||||
molo::llm::Message tr;
|
||||
tr.role = molo::llm::Role::kTool;
|
||||
tr.parts.push_back(molo::llm::ContentPart::of_result({"c1", "42", false}));
|
||||
req.messages.push_back(tr);
|
||||
molo::llm::ToolSpec spec;
|
||||
spec.name = "f";
|
||||
req.tools.push_back(spec);
|
||||
req.tool_choice = "required";
|
||||
req.max_tokens = 10;
|
||||
req.temperature = 0.3;
|
||||
req.json_mode = true;
|
||||
req.reasoning_effort = "low";
|
||||
req.extra.set("safe_prompt", Json(true));
|
||||
Json body = model.to_params(req).to_json();
|
||||
std::string s = body.dump();
|
||||
ASSERT_TRUE(has(s, "\"model\":\"mistral-small-latest\""));
|
||||
ASSERT_TRUE(has(s, "{\"content\":\"be brief\",\"role\":\"system\"}"));
|
||||
ASSERT_TRUE(has(s, "\"tool_call_id\":\"c1\""));
|
||||
ASSERT_TRUE(has(s, "\"arguments\":\"{\\\"x\\\":1}\""));
|
||||
ASSERT_TRUE(has(s, "\"tool_choice\":\"required\""));
|
||||
ASSERT_TRUE(has(s, "\"response_format\":{\"type\":\"json_object\"}"));
|
||||
ASSERT_TRUE(has(s, "\"reasoning_effort\":\"low\""));
|
||||
ASSERT_TRUE(has(s, "\"safe_prompt\":true"));
|
||||
// json_mode and schema together are refused
|
||||
req.response_schema = Json::parse("{\"type\":\"object\"}");
|
||||
ASSERT_THROW(model.to_params(req), ApiError);
|
||||
// a user image becomes an image_url chunk with a data URL
|
||||
molo::llm::ChatRequest img;
|
||||
molo::llm::Message u = molo::llm::Message::user("look");
|
||||
molo::llm::ImageData d;
|
||||
d.mime = "image/png";
|
||||
d.bytes = "abc";
|
||||
u.parts.push_back(molo::llm::ContentPart::of_image(d));
|
||||
img.messages.push_back(u);
|
||||
ASSERT_TRUE(has(model.to_params(img).to_json().dump(), "data:image/png;base64,YWJj"));
|
||||
}
|
||||
|
||||
TEST(mistral_chatmodel, generate_and_stream_through_the_seam) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/chat/completions", reply(kToolReply));
|
||||
rig.on(Method::kPost, "/v1/chat/completions", sse(kStream));
|
||||
MistralChatModel model(std::make_shared<Chat>(rig.client()), "mistral-large-latest");
|
||||
ASSERT_EQ(model.vendor(), "mistral");
|
||||
molo::llm::ChatRequest req;
|
||||
req.messages.push_back(molo::llm::Message::user("weather?"));
|
||||
molo::llm::ChatResponse r = model.generate(req);
|
||||
ASSERT_EQ(r.text(), "Checking.");
|
||||
ASSERT_EQ(r.finish_reason, "tool_calls");
|
||||
ASSERT_EQ(r.usage.total_tokens, 12);
|
||||
auto calls = r.tool_calls();
|
||||
ASSERT_EQ(calls.size(), 2u);
|
||||
ASSERT_EQ(calls[0].name, "get_weather");
|
||||
ASSERT_EQ(calls[0].arguments.find("city")->as_string(), "Paris");
|
||||
ASSERT_TRUE(has(rig.transport->seen()[0].body, "\"model\":\"mistral-large-latest\""));
|
||||
std::string text;
|
||||
std::string finish;
|
||||
model.stream(req, [&](const molo::llm::ChatChunk& c) {
|
||||
text += c.text_delta;
|
||||
if (!c.finish_reason.empty()) finish = c.finish_reason;
|
||||
return true;
|
||||
});
|
||||
ASSERT_EQ(text, "Hello");
|
||||
ASSERT_EQ(finish, "stop");
|
||||
}
|
||||
|
||||
TEST(mistral_chatmodel, model_length_is_reported_as_length) {
|
||||
ChatResult r = ChatResult::parse(Json::parse(
|
||||
"{\"id\":\"1\",\"model\":\"m\",\"choices\":[{\"index\":0,\"finish_reason\":\"model_length\",\"message\":{\"role\":\"assistant\",\"content\":\"x\"}}]}"));
|
||||
ASSERT_EQ(MistralChatModel::to_response(r).finish_reason, "length");
|
||||
ASSERT_THROW(MistralChatModel::to_response(ChatResult::parse(Json::parse("{\"choices\":[]}"))), ApiError);
|
||||
}
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
// Opt-in live checks. MOLO_LIVE_NET=1 enables the network; MISTRAL_API_KEY
|
||||
// (via llm::Config) enables the read-only calls plus ONE tiny completion.
|
||||
// Without them each test prints a loud SKIP. Nothing is created or deleted.
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "clients/transports/http_transport.h"
|
||||
#include "support.h"
|
||||
#include "vendors/mistral/chat.h"
|
||||
#include "vendors/mistral/files.h"
|
||||
#include "vendors/mistral/models.h"
|
||||
|
||||
using namespace molo::mistral;
|
||||
using molo::llm::ApiError;
|
||||
|
||||
namespace {
|
||||
// Read once at start-up: tests/src/llm unsets MOLO_LIVE_NET while the suite runs.
|
||||
const bool kNet = std::getenv("MOLO_LIVE_NET") != nullptr;
|
||||
bool net() { return kNet; }
|
||||
} // namespace
|
||||
|
||||
// No key needed: a deliberately invalid key must answer 401. Recorded probe:
|
||||
// 2026-10-25 every documented path answered 401 {"detail":"Invalid API Key"}.
|
||||
TEST(mistral_live, invalid_key_answers_401) {
|
||||
if (!net()) {
|
||||
std::cout << "SKIP mistral_live.invalid_key_answers_401 (set MOLO_LIVE_NET=1)\n";
|
||||
return;
|
||||
}
|
||||
auto client = std::make_shared<molo::llm::ApiClient>(
|
||||
std::make_unique<molo::clients::transports::HttpTransport>(), Platform::config(), "invalid-molo-probe");
|
||||
Models models(client);
|
||||
try {
|
||||
models.list();
|
||||
FAIL("expected 401");
|
||||
} catch (const ApiError& e) {
|
||||
std::cout << " GET /v1/models with an invalid key: " << e.http_status() << " " << e.type() << ": " << e.message() << "\n";
|
||||
ASSERT_EQ(e.http_status(), 401);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(mistral_live, models_files_and_one_tiny_completion) {
|
||||
Platform p = Platform::from_env();
|
||||
if (!net() || !p.configured()) {
|
||||
std::cout << "SKIP mistral_live.models_files_and_one_tiny_completion (set MOLO_LIVE_NET=1 and MISTRAL_API_KEY)\n";
|
||||
return;
|
||||
}
|
||||
ModelList models = Models(p.client).list();
|
||||
std::cout << " models: " << models.models.size() << "\n";
|
||||
ASSERT_TRUE(!models.models.empty());
|
||||
FileListParams lp;
|
||||
lp.page_size = 5;
|
||||
FileList files = Files(p.client).list(lp);
|
||||
std::cout << " files (first page): " << files.files.size() << "\n";
|
||||
ChatParams params = ChatParams::prompt("Reply with the single word: ok");
|
||||
params.max_tokens = 8;
|
||||
ChatResult r = Chat(p.client).create(params);
|
||||
std::cout << " completion finish=" << r.first().finish_reason << " tokens=" << r.usage.total_tokens << "\n";
|
||||
ASSERT_TRUE(r.usage.present);
|
||||
}
|
||||
+460
@@ -0,0 +1,460 @@
|
||||
// Services over the real ApiClient and a recording mock: models, files,
|
||||
// embeddings, moderation, classifiers, OCR, audio, batch, fine-tuning.
|
||||
// FIXTURE: replies verbatim from the docs.mistral.ai/openapi.yaml examples
|
||||
// (list_models, upload_file, list_files, embeddings, moderations, ocr,
|
||||
// transcriptions). SHAPE: replies built from the spec schema where the spec
|
||||
// has no example (values invented).
|
||||
#include "support.h"
|
||||
#include "vendors/mistral/audio.h"
|
||||
#include "vendors/mistral/chat_params.h"
|
||||
#include "vendors/mistral/batch.h"
|
||||
#include "vendors/mistral/classifiers.h"
|
||||
#include "vendors/mistral/embeddings.h"
|
||||
#include "vendors/mistral/files.h"
|
||||
#include "vendors/mistral/finetune.h"
|
||||
#include "vendors/mistral/models.h"
|
||||
#include "vendors/mistral/moderation.h"
|
||||
#include "vendors/mistral/ocr.h"
|
||||
|
||||
using namespace molo::mistral;
|
||||
using namespace mistral_test;
|
||||
using molo::llm::ApiError;
|
||||
|
||||
namespace {
|
||||
// FIXTURE: list_models userExample (the document's own placeholders kept)
|
||||
const char* kModels =
|
||||
"{\"object\":\"list\",\"data\":[{\"id\": \"<model_id>\", \"capabilities\": {\"completion_chat\": true, \"completion_fim\": false, "
|
||||
"\"function_calling\": false, \"fine_tuning\": false, \"vision\": false, \"classification\": false}, \"job\": \"<job_id>\", "
|
||||
"\"root\": \"open-mistral-7b\", \"object\": \"model\", \"created\": 1756746619, \"owned_by\": \"<owner_id>\", "
|
||||
"\"max_context_length\": 32768, \"aliases\": [], \"type\": \"fine-tuned\", \"archived\": false},"
|
||||
"{\"id\":\"mistral-small-latest\",\"object\":\"model\",\"created\":1,\"owned_by\":\"mistralai\",\"type\":\"base\","
|
||||
"\"capabilities\":{\"completion_chat\":true,\"vision\":true},\"max_context_length\":131072,\"aliases\":[\"mistral-small\"]}]}";
|
||||
// FIXTURE: upload_file userExample
|
||||
const char* kFile =
|
||||
"{\"id\": \"e85980c9-409e-4a46-9304-36588f6292b0\", \"object\": \"file\", \"bytes\": null, \"created_at\": 1759500189, "
|
||||
"\"filename\": \"example.file.jsonl\", \"purpose\": \"fine-tune\", \"sample_type\": \"instruct\", \"source\": \"upload\", "
|
||||
"\"num_lines\": 2, \"mimetype\": \"application/jsonl\", \"signature\": \"d4821d2de1917341\"}";
|
||||
// FIXTURE: list_files userExample
|
||||
const char* kFileList =
|
||||
"{\"data\": [{\"id\": \"f1\", \"object\": \"file\", \"bytes\": null, \"created_at\": 1759491994, \"filename\": \"a.jsonl\", "
|
||||
"\"purpose\": \"batch\", \"sample_type\": \"batch_result\", \"source\": \"mistral\", \"num_lines\": 2, \"mimetype\": \"application/jsonl\", \"signature\": null}, "
|
||||
"{\"id\": \"f2\", \"object\": \"file\", \"bytes\": null, \"created_at\": 1759491994, \"filename\": \"b.jsonl\", \"purpose\": \"batch\", "
|
||||
"\"sample_type\": \"batch_result\", \"source\": \"mistral\", \"num_lines\": 2, \"mimetype\": \"application/jsonl\", \"signature\": null}], \"object\": \"list\", \"total\": 2}";
|
||||
// FIXTURE: embeddings userExample
|
||||
const char* kEmbeddings =
|
||||
"{\"data\": [{\"embedding\": [-0.016632080078125, 0.0701904296875, 0.03143310546875, 0.01309967041015625, 0.0202789306640625], \"index\": 0, \"object\": \"embedding\"}, "
|
||||
"{\"embedding\": [-0.0230560302734375, 0.039337158203125, 0.0521240234375, -0.0184783935546875, 0.034271240234375], \"index\": 1, \"object\": \"embedding\"}], "
|
||||
"\"model\": \"mistral-embed\", \"object\": \"list\", \"usage\": {\"prompt_tokens\": 15, \"completion_tokens\": 0, \"total_tokens\": 15, \"prompt_audio_seconds\": null}}";
|
||||
// FIXTURE: moderations userExample (first result only; the example has two)
|
||||
const char* kModeration =
|
||||
"{\"id\": \"4d71ae510af942108ef7344f903e2b88\", \"model\": \"mistral-moderation-latest\", \"results\": [{\"categories\": {\"sexual\": false, "
|
||||
"\"hate_and_discrimination\": false, \"violence_and_threats\": true, \"selfharm\": false, \"pii\": false}, \"category_scores\": {\"sexual\": 0.0011335690505802631, "
|
||||
"\"hate_and_discrimination\": 0.0030753696337342262, \"violence_and_threats\": 0.93, \"selfharm\": 0.00017952796770259738, \"pii\": 0.0023967307060956955}}]}";
|
||||
// SHAPE: ClassificationResponse
|
||||
const char* kClassify =
|
||||
"{\"id\":\"mod-1\",\"model\":\"ft:classifier:x\",\"results\":[{\"sentiment\":{\"scores\":{\"positive\":0.9,\"negative\":0.1}},\"topic\":{\"scores\":{\"a\":0.2,\"b\":0.8}}}]}";
|
||||
// FIXTURE (trimmed): ocr userExample structure
|
||||
const char* kOcr =
|
||||
"{\"pages\": [{\"index\": 1, \"markdown\": \"# TITLE\\nBody\", \"images\": [], \"dimensions\": {\"dpi\": 200, \"height\": 2200, \"width\": 1700}},"
|
||||
"{\"index\": 2, \"markdown\": \"Page two\", \"images\": [{\"id\":\"i\"}], \"tables\": [{\"id\":\"t\"}], \"header\": \"H\"}],"
|
||||
"\"model\": \"mistral-ocr-2503-completion\", \"usage_info\": {\"pages_processed\": 29, \"doc_size_bytes\": 3002783}}";
|
||||
// FIXTURE (trimmed): transcriptions userExample
|
||||
const char* kTranscription =
|
||||
"{\"model\": \"voxtral-mini-2507\", \"text\": \"This week, I traveled to Chicago.\", \"language\": \"en\", "
|
||||
"\"segments\": [{\"type\":\"transcription_segment\",\"text\":\"This week\",\"start\":0.0,\"end\":1.5,\"speaker_id\":\"s1\"}], "
|
||||
"\"usage\": {\"prompt_tokens\": 4, \"completion_tokens\": 0, \"total_tokens\": 4, \"prompt_audio_seconds\": 11}}";
|
||||
// SHAPE: BatchJob
|
||||
const char* kBatch =
|
||||
"{\"id\":\"b1\",\"object\":\"batch\",\"input_files\":[\"f1\"],\"endpoint\":\"/v1/chat/completions\",\"model\":\"mistral-small-latest\","
|
||||
"\"errors\":[],\"status\":\"RUNNING\",\"created_at\":10,\"total_requests\":4,\"completed_requests\":1,\"succeeded_requests\":1,\"failed_requests\":0}";
|
||||
// SHAPE: fine-tuning job
|
||||
const char* kJob =
|
||||
"{\"id\":\"j1\",\"auto_start\":false,\"model\":\"open-mistral-7b\",\"status\":\"QUEUED\",\"created_at\":1,\"modified_at\":2,\"training_files\":[\"f1\"],\"object\":\"job\",\"job_type\":\"completion\",\"trained_tokens\":0}";
|
||||
} // namespace
|
||||
|
||||
TEST(mistral_models, list_get_and_explicit_delete) {
|
||||
Rig rig;
|
||||
rig.on(Method::kGet, "/v1/models", reply(kModels));
|
||||
rig.on(Method::kGet, "/v1/models/mistral-small-latest", reply("{\"id\":\"mistral-small-latest\",\"type\":\"base\",\"capabilities\":{\"vision\":true}}"));
|
||||
rig.on(Method::kDelete, "/v1/models/ft:open-mistral-7b:a:b:c", reply("{\"id\":\"ft:open-mistral-7b:a:b:c\",\"object\":\"model\",\"deleted\":true}"));
|
||||
Models m(rig.client());
|
||||
ModelList l = m.list("mistral", "small");
|
||||
ASSERT_EQ(l.models.size(), 2u);
|
||||
ASSERT_TRUE(l.models[0].fine_tuned());
|
||||
ASSERT_EQ(l.models[0].root, "open-mistral-7b");
|
||||
ASSERT_TRUE(l.models[0].capabilities.completion_chat);
|
||||
ASSERT_FALSE(l.models[0].capabilities.vision);
|
||||
ASSERT_TRUE(l.find("mistral-small-latest")->capabilities.vision);
|
||||
ASSERT_EQ(l.find("mistral-small-latest")->aliases.size(), 1u);
|
||||
ASSERT_TRUE(has(rig.transport->seen()[0].target, "provider=mistral"));
|
||||
ASSERT_TRUE(has(rig.transport->seen()[0].target, "model=small"));
|
||||
ASSERT_TRUE(m.get("mistral-small-latest").capabilities.vision);
|
||||
ASSERT_TRUE(m.remove("ft:open-mistral-7b:a:b:c").deleted);
|
||||
ASSERT_THROW(m.get("../etc"), ApiError);
|
||||
ASSERT_THROW(m.remove(""), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_files, upload_list_get_download_url_delete) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/files", reply(kFile));
|
||||
rig.on(Method::kGet, "/v1/files", reply(kFileList));
|
||||
rig.on(Method::kGet, "/v1/files/e85980c9-409e-4a46-9304-36588f6292b0", reply(kFile));
|
||||
rig.on(Method::kGet, "/v1/files/f1/content", reply("{\"a\":1}\n", 200, "application/octet-stream"));
|
||||
rig.on(Method::kGet, "/v1/files/f1/url", reply("{\"url\":\"https://signed.example/x\"}"));
|
||||
rig.on(Method::kDelete, "/v1/files/f1", reply("{\"id\":\"f1\",\"object\":\"file\",\"deleted\":true}"));
|
||||
Files files(rig.client());
|
||||
FileUploadParams up;
|
||||
up.filename = "example.file.jsonl";
|
||||
up.data = "{\"messages\":[]}\n";
|
||||
up.expiry_hours = 24;
|
||||
FileInfo f = files.upload(up);
|
||||
ASSERT_EQ(f.id, "e85980c9-409e-4a46-9304-36588f6292b0");
|
||||
ASSERT_EQ(f.purpose, "fine-tune");
|
||||
ASSERT_EQ(f.num_lines, 2L);
|
||||
auto req = rig.transport->seen()[0];
|
||||
ASSERT_TRUE(has(req.headers.get_or("Content-Type", ""), "multipart/form-data"));
|
||||
ASSERT_TRUE(has(req.body, "name=\"purpose\""));
|
||||
ASSERT_TRUE(has(req.body, "fine-tune"));
|
||||
ASSERT_TRUE(has(req.body, "name=\"expiry\""));
|
||||
ASSERT_TRUE(has(req.body, "filename=\"example.file.jsonl\""));
|
||||
FileList l = files.list();
|
||||
ASSERT_EQ(l.files.size(), 2u);
|
||||
ASSERT_EQ(l.total, 2L);
|
||||
ASSERT_TRUE(has(rig.transport->seen()[1].target, "page_size=100"));
|
||||
ASSERT_EQ(files.get("e85980c9-409e-4a46-9304-36588f6292b0").sample_type, "instruct");
|
||||
ASSERT_EQ(files.download("f1"), "{\"a\":1}\n");
|
||||
ASSERT_EQ(files.signed_url("f1", 2), "https://signed.example/x");
|
||||
ASSERT_TRUE(has(rig.last().target, "expiry=2"));
|
||||
ASSERT_TRUE(files.remove("f1").deleted);
|
||||
}
|
||||
|
||||
TEST(mistral_files, validation_before_the_network) {
|
||||
Rig rig;
|
||||
Files files(rig.client());
|
||||
FileUploadParams up;
|
||||
up.data = "x";
|
||||
ASSERT_THROW(files.upload(up), ApiError); // no filename
|
||||
up.filename = "a/b.jsonl";
|
||||
ASSERT_THROW(files.upload(up), ApiError);
|
||||
up.filename = "a.jsonl";
|
||||
up.data.clear();
|
||||
ASSERT_THROW(files.upload(up), ApiError);
|
||||
up.data = "x";
|
||||
up.purpose = "chat";
|
||||
ASSERT_THROW(files.upload(up), ApiError);
|
||||
up.purpose = "ocr";
|
||||
up.visibility = "everyone";
|
||||
ASSERT_THROW(files.upload(up), ApiError);
|
||||
FileListParams lp;
|
||||
lp.page_size = 101;
|
||||
ASSERT_THROW(files.list(lp), ApiError);
|
||||
lp.page_size = 10;
|
||||
lp.page = -1;
|
||||
ASSERT_THROW(files.list(lp), ApiError);
|
||||
ASSERT_THROW(files.signed_url("f1", 0), ApiError);
|
||||
ASSERT_THROW(files.signed_url("f1", 169), ApiError);
|
||||
ASSERT_THROW(files.get("a b"), ApiError);
|
||||
ASSERT_THROW(files.remove("../x"), ApiError);
|
||||
ASSERT_EQ(rig.transport->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(mistral_files, list_all_walks_pages_and_reports_truncation) {
|
||||
Rig rig;
|
||||
// page_size 1: the first two pages are full, the third is empty
|
||||
rig.on(Method::kGet, "/v1/files", reply("{\"data\":[{\"id\":\"a\"}],\"object\":\"list\",\"total\":2}"), 2);
|
||||
rig.on(Method::kGet, "/v1/files", reply("{\"data\":[],\"object\":\"list\",\"total\":2}"));
|
||||
Files files(rig.client());
|
||||
FileListParams p;
|
||||
p.page_size = 1;
|
||||
FileList all = files.list_all(p);
|
||||
ASSERT_EQ(all.files.size(), 2u);
|
||||
ASSERT_FALSE(all.truncated);
|
||||
ASSERT_TRUE(has(rig.transport->seen()[1].target, "page=1"));
|
||||
// an endless full page hits the walk cap and says so
|
||||
Rig endless;
|
||||
endless.on(Method::kGet, "/v1/files", reply("{\"data\":[{\"id\":\"a\"}],\"object\":\"list\",\"total\":99999}"), 100);
|
||||
FileList cut = Files(endless.client()).list_all(p);
|
||||
ASSERT_TRUE(cut.truncated);
|
||||
ASSERT_EQ(cut.files.size(), 20u); // kMaxWalkPages
|
||||
}
|
||||
|
||||
TEST(mistral_embeddings, request_and_documented_reply) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/embeddings", reply(kEmbeddings));
|
||||
Embeddings e(rig.client());
|
||||
EmbeddingParams p;
|
||||
p.inputs = {"Embed this sentence.", "As well as this one."};
|
||||
p.output_dimension = 5;
|
||||
EmbeddingResult r = e.create(p);
|
||||
ASSERT_EQ(r.vectors.size(), 2u);
|
||||
ASSERT_EQ(r.vectors[1].size(), 5u);
|
||||
ASSERT_EQ(r.usage.total_tokens, 15);
|
||||
ASSERT_EQ(r.model, "mistral-embed");
|
||||
std::string body = rig.last().body;
|
||||
ASSERT_TRUE(has(body, "\"model\":\"mistral-embed\""));
|
||||
ASSERT_TRUE(has(body, "\"input\":[\"Embed this sentence.\",\"As well as this one.\"]"));
|
||||
ASSERT_TRUE(has(body, "\"output_dimension\":5"));
|
||||
p.inputs = {"one"};
|
||||
ASSERT_TRUE(has(p.to_json().dump(), "\"input\":\"one\""));
|
||||
p.inputs.clear();
|
||||
ASSERT_THROW(p.validate(), ApiError);
|
||||
p.inputs = std::vector<std::string>(513, "x");
|
||||
ASSERT_THROW(p.validate(), ApiError);
|
||||
p.inputs = {"x"};
|
||||
p.output_dtype = "float16";
|
||||
ASSERT_THROW(p.validate(), ApiError);
|
||||
p.output_dtype.clear();
|
||||
p.output_dimension = 0;
|
||||
ASSERT_THROW(p.validate(), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_moderation, text_chat_and_classifiers) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/moderations", reply(kModeration));
|
||||
rig.on(Method::kPost, "/v1/chat/moderations", reply(kModeration));
|
||||
rig.on(Method::kPost, "/v1/classifications", reply(kClassify));
|
||||
rig.on(Method::kPost, "/v1/chat/classifications", reply(kClassify));
|
||||
Moderation mod(rig.client());
|
||||
ModerationResult r = mod.moderate({"text"});
|
||||
ASSERT_EQ(r.results.size(), 1u);
|
||||
ASSERT_TRUE(r.results[0].flagged());
|
||||
ASSERT_EQ(r.results[0].flagged_categories().size(), 1u);
|
||||
ASSERT_EQ(r.results[0].flagged_categories()[0], "violence_and_threats");
|
||||
ASSERT_TRUE(r.results[0].scores.at("violence_and_threats") > 0.9);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"input\":\"text\""));
|
||||
ASSERT_TRUE(has(rig.last().body, "\"model\":\"mistral-moderation-latest\""));
|
||||
mod.moderate_chat({Messages::user("hi"), Messages::assistant("hello")});
|
||||
ASSERT_TRUE(has(rig.last().body, "\"input\":[{"));
|
||||
Classifiers cls(rig.client());
|
||||
ClassificationResult c = cls.classify("ft:classifier:x", {"a", "b"});
|
||||
ASSERT_EQ(c.results.size(), 1u);
|
||||
ASSERT_EQ(c.top_label(0, "sentiment"), "positive");
|
||||
ASSERT_EQ(c.top_label(0, "topic"), "b");
|
||||
ASSERT_EQ(c.top_label(0, "missing"), "");
|
||||
ASSERT_EQ(c.top_label(5, "topic"), "");
|
||||
cls.classify_chat("ft:classifier:x", {Messages::user("hi")});
|
||||
ASSERT_TRUE(has(rig.last().body, "\"input\":{\"messages\":[{"));
|
||||
ASSERT_THROW(mod.moderate({}), ApiError);
|
||||
ASSERT_THROW(mod.moderate({""}), ApiError);
|
||||
ASSERT_THROW(mod.moderate_chat({}), ApiError);
|
||||
ASSERT_THROW(mod.moderate_chat({Json("x")}), ApiError);
|
||||
ASSERT_THROW(cls.classify("bad model", {"a"}), ApiError);
|
||||
ASSERT_THROW(cls.classify("m", std::vector<std::string>(257, "x")), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_ocr, document_forms_and_documented_reply) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/ocr", reply(kOcr), 3);
|
||||
Ocr ocr(rig.client());
|
||||
OcrParams p;
|
||||
p.reference = "https://arxiv.org/pdf/2201.04234";
|
||||
p.pages = {0, 1};
|
||||
p.table_format = "html";
|
||||
OcrResult r = ocr.process(p);
|
||||
ASSERT_EQ(r.pages.size(), 2u);
|
||||
ASSERT_EQ(r.pages_processed, 29L);
|
||||
ASSERT_EQ(r.pages[1].images, 1u);
|
||||
ASSERT_EQ(r.pages[1].tables, 1u);
|
||||
ASSERT_EQ(r.pages[1].header, "H");
|
||||
ASSERT_EQ(r.markdown(), "# TITLE\nBody\n\nPage two");
|
||||
std::string body = rig.last().body;
|
||||
ASSERT_TRUE(has(body, "\"document\":{\"document_url\":\"https://arxiv.org/pdf/2201.04234\",\"type\":\"document_url\"}"));
|
||||
ASSERT_TRUE(has(body, "\"model\":\"mistral-ocr-latest\""));
|
||||
ASSERT_TRUE(has(body, "\"pages\":[0,1]"));
|
||||
p.source = OcrSource::kFileId;
|
||||
p.reference = "file-1";
|
||||
ocr.process(p);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"document\":{\"file_id\":\"file-1\",\"type\":\"file\"}"));
|
||||
p.source = OcrSource::kImageUrl;
|
||||
p.reference = "data:image/png;base64,AAAA";
|
||||
ocr.process(p);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"type\":\"image_url\""));
|
||||
p.reference = "ftp://x";
|
||||
ASSERT_THROW(ocr.process(p), ApiError);
|
||||
p.source = OcrSource::kDocumentUrl;
|
||||
p.reference = "https://x.test/a.pdf";
|
||||
p.pages = {-1};
|
||||
ASSERT_THROW(ocr.process(p), ApiError);
|
||||
p.pages.clear();
|
||||
p.table_format = "csv";
|
||||
ASSERT_THROW(ocr.process(p), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_audio, transcription_speech_and_voices) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/audio/transcriptions", reply(kTranscription), 2);
|
||||
rig.on(Method::kPost, "/v1/audio/speech", reply("{\"audio_data\":\"AAAA\"}"));
|
||||
rig.on(Method::kGet, "/v2/audio/voices", reply("{\"data\":[],\"next_page_token\":null}"));
|
||||
rig.on(Method::kGet, "/v1/audio/voices/v1/sample", reply("RIFFwav", 200, "audio/wav"));
|
||||
rig.on(Method::kDelete, "/v1/audio/voices/v1", reply("{\"id\":\"v1\"}"));
|
||||
Audio a(rig.client());
|
||||
TranscriptionParams t;
|
||||
t.file_data = "RIFF....";
|
||||
t.file_name = "a.wav";
|
||||
t.language = "en";
|
||||
t.diarize = true;
|
||||
t.timestamp_granularities = {"segment"};
|
||||
t.context_bias = {"Voxtral"};
|
||||
TranscriptionResult r = a.transcribe(t);
|
||||
ASSERT_EQ(r.text, "This week, I traveled to Chicago.");
|
||||
ASSERT_EQ(r.language, "en");
|
||||
ASSERT_EQ(r.segments.size(), 1u);
|
||||
ASSERT_EQ(r.segments[0].speaker_id, "s1");
|
||||
ASSERT_EQ(r.usage.prompt_audio_seconds, 11);
|
||||
auto s = rig.transport->seen()[0];
|
||||
ASSERT_TRUE(has(s.headers.get_or("Content-Type", ""), "multipart/form-data"));
|
||||
ASSERT_TRUE(has(s.body, "name=\"model\""));
|
||||
ASSERT_TRUE(has(s.body, "voxtral-mini-latest"));
|
||||
ASSERT_TRUE(has(s.body, "name=\"diarize\""));
|
||||
ASSERT_TRUE(has(s.body, "name=\"context_bias\""));
|
||||
ASSERT_TRUE(has(s.body, "name=\"timestamp_granularities\""));
|
||||
ASSERT_TRUE(has(s.body, "filename=\"a.wav\""));
|
||||
TranscriptionParams u;
|
||||
u.file_url = "https://x.test/a.mp3";
|
||||
a.transcribe(u);
|
||||
ASSERT_TRUE(has(rig.last().body, "name=\"file_url\""));
|
||||
// exactly one source
|
||||
TranscriptionParams none;
|
||||
ASSERT_THROW(a.transcribe(none), ApiError);
|
||||
TranscriptionParams two = u;
|
||||
two.file_id = "f1";
|
||||
ASSERT_THROW(a.transcribe(two), ApiError);
|
||||
TranscriptionParams longurl;
|
||||
longurl.file_url = "https://x.test/" + std::string(2100, 'a');
|
||||
ASSERT_THROW(a.transcribe(longurl), ApiError);
|
||||
TranscriptionParams badg = u;
|
||||
badg.timestamp_granularities = {"phoneme"};
|
||||
ASSERT_THROW(a.transcribe(badg), ApiError);
|
||||
|
||||
SpeechParams sp;
|
||||
sp.input = "Hello";
|
||||
sp.response_format = "mp3";
|
||||
a.speech(sp);
|
||||
ASSERT_TRUE(has(rig.last().body, "\"input\":\"Hello\""));
|
||||
sp.voice_id = "v1";
|
||||
sp.ref_audio = "AAAA";
|
||||
ASSERT_THROW(a.speech(sp), ApiError);
|
||||
a.voices();
|
||||
ASSERT_TRUE(has(rig.last().target, "page_size=50"));
|
||||
ASSERT_EQ(a.voice_sample("v1"), "RIFFwav");
|
||||
a.remove_voice("v1");
|
||||
ASSERT_THROW(a.update_voice("v1", Json::parse("{\"bogus\":1}")), ApiError);
|
||||
ASSERT_THROW(a.voice("../x"), ApiError);
|
||||
}
|
||||
|
||||
TEST(mistral_batch, create_list_get_cancel_delete) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/batch/jobs", reply(kBatch));
|
||||
rig.on(Method::kGet, "/v1/batch/jobs", reply("{\"data\":[],\"object\":\"list\",\"total\":0}"));
|
||||
rig.on(Method::kGet, "/v1/batch/jobs/b1", reply(kBatch));
|
||||
rig.on(Method::kPost, "/v1/batch/jobs/b1/cancel", reply(kBatch));
|
||||
rig.on(Method::kDelete, "/v1/batch/jobs/b1", reply("{\"id\":\"b1\",\"object\":\"batch\",\"deleted\":true}"));
|
||||
Batch b(rig.client());
|
||||
BatchParams p;
|
||||
p.model = "mistral-small-latest";
|
||||
p.input_files = {"f1"};
|
||||
p.metadata.set("k", Json("v"));
|
||||
BatchJob j = b.create(p);
|
||||
ASSERT_EQ(j.id, "b1");
|
||||
ASSERT_EQ(j.status, "RUNNING");
|
||||
ASSERT_EQ(j.total_requests, 4L);
|
||||
ASSERT_FALSE(j.terminal());
|
||||
ASSERT_TRUE(has(rig.last().body, "\"endpoint\":\"/v1/chat/completions\""));
|
||||
ASSERT_TRUE(has(rig.last().body, "\"input_files\":[\"f1\"]"));
|
||||
ASSERT_FALSE(has(rig.last().body, "timeout_hours"));
|
||||
BatchListParams lp;
|
||||
lp.status = "RUNNING";
|
||||
ASSERT_EQ(b.list(lp).items, 0u);
|
||||
ASSERT_TRUE(has(rig.last().target, "status=RUNNING"));
|
||||
ASSERT_EQ(b.get("b1", true).id, "b1");
|
||||
ASSERT_TRUE(has(rig.last().target, "inline=true"));
|
||||
ASSERT_EQ(b.cancel("b1").id, "b1");
|
||||
ASSERT_TRUE(b.remove("b1").find("deleted")->as_bool());
|
||||
}
|
||||
|
||||
TEST(mistral_batch, validation_before_the_network) {
|
||||
Rig rig;
|
||||
Batch b(rig.client());
|
||||
BatchParams p;
|
||||
ASSERT_THROW(b.create(p), ApiError); // nothing set
|
||||
p.model = "m";
|
||||
ASSERT_THROW(b.create(p), ApiError); // no input
|
||||
p.input_files = {"f1"};
|
||||
p.requests.push_back({"c", Json::object()});
|
||||
ASSERT_THROW(b.create(p), ApiError); // both inputs
|
||||
p.requests.clear();
|
||||
p.agent_id = "ag";
|
||||
ASSERT_THROW(b.create(p), ApiError); // model and agent
|
||||
p.agent_id.clear();
|
||||
p.endpoint = "/v1/images";
|
||||
ASSERT_THROW(b.create(p), ApiError);
|
||||
p.endpoint = "/v1/embeddings";
|
||||
p.timeout_hours = 169;
|
||||
ASSERT_THROW(b.create(p), ApiError);
|
||||
p.timeout_hours = 0;
|
||||
ASSERT_THROW(b.create(p), ApiError);
|
||||
p.timeout_hours = 24;
|
||||
p.input_files.clear();
|
||||
p.requests.assign(10001, BatchRequestItem{});
|
||||
ASSERT_THROW(b.create(p), ApiError);
|
||||
BatchListParams lp;
|
||||
lp.status = "DONE";
|
||||
ASSERT_THROW(b.list(lp), ApiError);
|
||||
ASSERT_THROW(b.get("a/b"), ApiError);
|
||||
ASSERT_EQ(rig.transport->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(mistral_finetuning, jobs_models_and_validation) {
|
||||
Rig rig;
|
||||
rig.on(Method::kPost, "/v1/fine_tuning/jobs", reply(kJob));
|
||||
rig.on(Method::kPost, "/v1/fine_tuning/jobs/j1/start", reply(kJob));
|
||||
rig.on(Method::kPost, "/v1/fine_tuning/jobs/j1/cancel", reply(kJob));
|
||||
rig.on(Method::kGet, "/v1/fine_tuning/jobs/j1", reply(kJob));
|
||||
rig.on(Method::kGet, "/v1/fine_tuning/jobs", reply("{\"data\":[],\"object\":\"list\",\"total\":0}"));
|
||||
rig.on(Method::kPost, "/v1/fine_tuning/models/ft:m:1/archive", reply("{\"id\":\"ft:m:1\",\"object\":\"model\",\"archived\":true}"));
|
||||
rig.on(Method::kDelete, "/v1/fine_tuning/models/ft:m:1/archive", reply("{\"id\":\"ft:m:1\",\"object\":\"model\",\"archived\":false}"));
|
||||
rig.on(Method::kPatch, "/v1/fine_tuning/models/ft:m:1", reply("{\"id\":\"ft:m:1\"}"));
|
||||
FineTuning ft(rig.client());
|
||||
FineTuneJobParams p;
|
||||
p.model = "open-mistral-7b";
|
||||
p.training_files.push_back({"f1", 1.0});
|
||||
p.hyperparameters.set("training_steps", Json(10));
|
||||
p.hyperparameters.set("learning_rate", Json(0.0001));
|
||||
p.dry_run = true;
|
||||
FineTuneJob j = ft.create_job(p);
|
||||
ASSERT_EQ(j.id, "j1");
|
||||
ASSERT_EQ(j.status, "QUEUED");
|
||||
ASSERT_FALSE(j.terminal());
|
||||
ASSERT_TRUE(has(rig.last().target, "dry_run=true"));
|
||||
ASSERT_TRUE(has(rig.last().body, "\"training_files\":[{\"file_id\":\"f1\",\"weight\":1}]"));
|
||||
ASSERT_EQ(ft.start_job("j1").id, "j1");
|
||||
ASSERT_EQ(ft.get_job("j1").job_type, "completion");
|
||||
ASSERT_EQ(ft.cancel_job("j1").id, "j1");
|
||||
ASSERT_EQ(ft.list_jobs().items, 0u);
|
||||
ft.archive_model("ft:m:1");
|
||||
ft.unarchive_model("ft:m:1");
|
||||
ft.update_model("ft:m:1", "name", "");
|
||||
ASSERT_TRUE(has(rig.last().body, "\"name\":\"name\""));
|
||||
ASSERT_THROW(ft.update_model("ft:m:1", "", ""), ApiError);
|
||||
FineTuneJobParams bad;
|
||||
ASSERT_THROW(ft.create_job(bad), ApiError);
|
||||
bad = p;
|
||||
bad.hyperparameters = Json::object();
|
||||
ASSERT_THROW(ft.create_job(bad), ApiError);
|
||||
bad = p;
|
||||
bad.training_files.clear();
|
||||
ASSERT_THROW(ft.create_job(bad), ApiError);
|
||||
bad = p;
|
||||
bad.suffix = std::string(19, 'a');
|
||||
ASSERT_THROW(ft.create_job(bad), ApiError);
|
||||
bad = p;
|
||||
bad.invalid_sample_skip_percentage = 1.5;
|
||||
ASSERT_THROW(ft.create_job(bad), ApiError);
|
||||
FineTuneListParams lp;
|
||||
lp.status = "DONE";
|
||||
ASSERT_THROW(ft.list_jobs(lp), ApiError);
|
||||
ASSERT_THROW(ft.cancel_job("a b"), ApiError);
|
||||
FineTuneJob done;
|
||||
done.status = "SUCCESS";
|
||||
ASSERT_TRUE(done.terminal());
|
||||
}
|
||||
Reference in New Issue
Block a user