feat(clients): mistral: La Plateforme package, 347-op call table, typed services, ChatModel, demo

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-25 15:08:12 +01:00
co-authored by Claude Sonnet 5.5
parent 3db67fcf1f
commit d2e2888ef4
62 changed files with 7573 additions and 3 deletions
+60
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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());
}