Merge anthropic core package
This commit is contained in:
@@ -0,0 +1,26 @@
|
||||
// Route: POST /ai/anthropic/build (offline: validates, never calls the vendor)
|
||||
#include "support/Assert.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
unsetenv("ANTHROPIC_API_KEY");
|
||||
Fixture f;
|
||||
auto ok = f.client->post("/ai/anthropic/build",
|
||||
R"({"model":"claude-opus-5-5","max_tokens":4096,"prompt":"hi","tools":[{"type":"advisor_20260301","model":"claude-opus-5-5"}],"thinking":{"type":"enabled","budget_tokens":2048}})",
|
||||
"application/json");
|
||||
check(ok.status == 200, "build 200 without a credential");
|
||||
check(contains(ok.body, "advisor-tool-2026-03-01"), "derived beta reported");
|
||||
check(contains(ok.body, "\"anthropic_version\":\"2023-06-01\""), "default version");
|
||||
check(contains(ok.body, "\"budget_tokens\":2048"), "thinking in the body");
|
||||
auto v26 = f.client->post("/ai/anthropic/build",
|
||||
R"({"model":"m","prompt":"hi","version":"2026-10-21","temperature":0.5})", "application/json");
|
||||
check(v26.status == 422, "temperature rejected under 2026-10-21");
|
||||
auto v23 = f.client->post("/ai/anthropic/build",
|
||||
R"({"model":"m","prompt":"hi","temperature":0.5})", "application/json");
|
||||
check(v23.status == 200 && contains(v23.body, "\"temperature\":0.5"), "temperature kept under 2023-06-01");
|
||||
auto mcp = f.client->post("/ai/anthropic/build",
|
||||
R"({"model":"m","prompt":"hi","tools":[{"type":"mcp_toolset","mcp_server_name":"x"}]})", "application/json");
|
||||
check(mcp.status == 422, "toolset without a server is rejected");
|
||||
return finish("ai/anthropic/core/build");
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
// 503 anthropic_not_configured on every route that would call the vendor;
|
||||
// paid and destructive routes are dry runs (200) until confirm:true.
|
||||
#include "support/Assert.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
unsetenv("ANTHROPIC_API_KEY");
|
||||
Fixture f;
|
||||
auto post = [&](const std::string& path, const std::string& body) {
|
||||
return f.client->post("/ai/anthropic/" + path, body, "application/json");
|
||||
};
|
||||
auto r = post("models", R"({"limit":3})");
|
||||
check(r.status == 503 && contains(r.body, "anthropic_not_configured"), "models: 503 without a key");
|
||||
check(post("count", R"({"model":"m","prompt":"x"})").status == 503, "count: 503");
|
||||
check(post("batches", R"({"action":"list"})").status == 503, "batches list: 503");
|
||||
check(post("batches", R"({"action":"get","id":"msgbatch_1"})").status == 503, "batches get: 503");
|
||||
check(post("batches", R"({"action":"results","id":"msgbatch_1"})").status == 503, "batches results: 503");
|
||||
check(post("files", R"({"action":"list"})").status == 503, "files list: 503");
|
||||
check(post("skills", R"({"action":"list"})").status == 503, "skills list: 503");
|
||||
check(post("profiles", R"({"action":"list"})").status == 503, "profiles list: 503");
|
||||
|
||||
auto dry = post("messages", R"({"model":"claude-opus-5-5","prompt":"hi"})");
|
||||
check(dry.status == 200 && contains(dry.body, "\"dry_run\":true"), "messages: dry run without confirm");
|
||||
check(post("messages", R"({"model":"claude-opus-5-5","prompt":"hi","confirm":true})").status == 503, "messages confirmed: 503");
|
||||
check(contains(post("stream", R"({"model":"m","prompt":"hi"})").body, "\"dry_run\":true"), "stream: dry run");
|
||||
check(post("stream", R"({"model":"m","prompt":"hi","confirm":true})").status == 503, "stream confirmed: 503");
|
||||
check(contains(post("batches", R"({"action":"cancel","id":"msgbatch_1"})").body, "\"dry_run\":true"), "batch cancel: dry run");
|
||||
check(contains(post("batches", R"({"action":"delete","id":"msgbatch_1"})").body, "\"dry_run\":true"), "batch delete: dry run");
|
||||
check(post("batches", R"({"action":"delete","id":"msgbatch_1","confirm":true})").status == 503, "batch delete confirmed: 503");
|
||||
check(contains(post("batches", R"({"action":"create","requests":[{"custom_id":"a","params":{"model":"m","prompt":"x"}}]})").body, "\"dry_run\":true"), "batch create: dry run");
|
||||
check(contains(post("files", R"({"action":"delete","id":"file_1"})").body, "\"dry_run\":true"), "file delete: dry run");
|
||||
check(contains(post("files", R"({"action":"upload","filename":"a.txt","text":"hello"})").body, "\"dry_run\":true"), "file upload: dry run");
|
||||
check(contains(post("skills", R"({"action":"delete","id":"skill_1"})").body, "\"dry_run\":true"), "skill delete: dry run");
|
||||
check(contains(post("profiles", R"({"action":"delete","id":"uprof_1"})").body, "\"dry_run\":true"), "profile delete: dry run");
|
||||
return finish("ai/anthropic/core/credential");
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
// Routes: GET /ai/anthropic (page), /status, /calls, /betas, /tools
|
||||
#include "support/Assert.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
unsetenv("ANTHROPIC_API_KEY");
|
||||
Fixture f;
|
||||
auto page = f.client->get("/ai/anthropic");
|
||||
check(page.status == 200, "page 200");
|
||||
check(contains(page.body, "Anthropic Claude"), "page has its heading");
|
||||
check(contains(page.body, "ai_anthropic_core.js"), "page loads its script");
|
||||
auto st = f.client->get("/ai/anthropic/status");
|
||||
check(st.status == 200, "status 200");
|
||||
check(contains(st.body, "\"configured\":false"), "no credential reported");
|
||||
check(contains(st.body, "\"key_env\":\"ANTHROPIC_API_KEY\""), "names the key variable");
|
||||
check(contains(st.body, "\"calls\":32"), "reports 32 calls");
|
||||
check(contains(st.body, "\"betas\":55"), "reports 55 betas");
|
||||
auto calls = f.client->get("/ai/anthropic/calls");
|
||||
check(calls.status == 200 && contains(calls.body, "messages.batches.results"), "call table listed");
|
||||
check(contains(calls.body, "/v1/skills/{skill_id}/versions/{version}/content"), "download row listed");
|
||||
auto betas = f.client->get("/ai/anthropic/betas");
|
||||
check(betas.status == 200 && contains(betas.body, "interleaved-thinking-2025-05-14"), "betas listed");
|
||||
check(contains(betas.body, "admin_package"), "other-package betas are labelled");
|
||||
auto tools = f.client->get("/ai/anthropic/tools");
|
||||
check(tools.status == 200 && contains(tools.body, "web_fetch_20260318"), "tools listed");
|
||||
check(f.client->post("/ai/anthropic/status", "{}", "application/json").status == 405, "post status is 405");
|
||||
check(f.client->get("/ai/anthropic/messages").status == 405, "get messages is 405");
|
||||
return finish("ai/anthropic/core/status");
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
// 422 on bad input, 413 on oversize, before any credential check
|
||||
#include "support/Assert.hpp"
|
||||
|
||||
using namespace molo::example::test;
|
||||
|
||||
int main() {
|
||||
unsetenv("ANTHROPIC_API_KEY");
|
||||
Fixture f;
|
||||
auto post = [&](const std::string& path, const std::string& body) {
|
||||
return f.client->post("/ai/anthropic/" + path, body, "application/json").status;
|
||||
};
|
||||
check(post("messages", "not json") == 422, "messages: invalid JSON is 422");
|
||||
check(post("messages", "[]") == 422, "messages: array body is 422");
|
||||
check(post("messages", "{}") == 422, "messages: model required");
|
||||
check(post("messages", R"({"model":"m"})") == 422, "messages: prompt or messages required");
|
||||
check(post("messages", R"({"model":"m","prompt":"x","max_tokens":-5})") == 422, "messages: negative max_tokens");
|
||||
check(post("messages", R"({"model":"m","prompt":"x","speed":"turbo"})") == 422, "messages: bad speed");
|
||||
check(post("stream", R"({"model":"m","prompt":"x","confirm":"yes"})") == 422, "stream: confirm must be a bool");
|
||||
check(post("count", "{}") == 422, "count: model required");
|
||||
check(post("batches", "{}") == 422, "batches: action required");
|
||||
check(post("batches", R"({"action":"explode"})") == 422, "batches: unknown action");
|
||||
check(post("batches", R"({"action":"get"})") == 422, "batches: id required");
|
||||
check(post("batches", R"({"action":"get","id":"../x"})") == 422, "batches: bad id");
|
||||
check(post("batches", R"({"action":"create","requests":"x"})") == 422, "batches: requests must be an array");
|
||||
check(post("files", R"({"action":"delete","id":"a/b"})") == 422, "files: bad id");
|
||||
check(post("files", R"({"action":"upload","filename":"x.txt"})") == 422, "files: upload needs text");
|
||||
check(post("skills", R"({"action":"get"})") == 422, "skills: id required");
|
||||
check(post("profiles", R"({"action":"nope"})") == 422, "profiles: unknown action");
|
||||
check(post("models", R"({"id":"../x"})") == 422, "models: bad id");
|
||||
std::string big(600 * 1024, 'x');
|
||||
check(post("messages", R"({"model":"m","prompt":")" + big + R"("})") == 413, "oversize body is 413");
|
||||
return finish("ai/anthropic/core/validation");
|
||||
}
|
||||
@@ -0,0 +1,458 @@
|
||||
#pragma once
|
||||
|
||||
// Streams copied verbatim from the vendor docs (build-with-claude/streaming, 'Full HTTP stream
|
||||
// response'). Fixtures, not scripted replies: they exercise the decoder and accumulator.
|
||||
|
||||
namespace anthropic_fixtures {
|
||||
|
||||
inline const char* kStreamBasic = R"SSE(event: message_start
|
||||
data: {"type": "message_start", "message": {"id": "msg_1nZdL29xx5MUA1yADyHTEsnR8uuvGzszyY", "type": "message", "role": "assistant", "content": [], "model": "claude-opus-5-5", "stop_reason": null, "stop_sequence": null, "usage": {"input_tokens": 25, "output_tokens": 1}}}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}}
|
||||
|
||||
event: ping
|
||||
data: {"type": "ping"}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "Hello"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": "!"}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type": "content_block_stop", "index": 0}
|
||||
|
||||
event: message_delta
|
||||
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence":null}, "usage": {"output_tokens": 15}}
|
||||
|
||||
event: message_stop
|
||||
data: {"type": "message_stop"}
|
||||
)SSE";
|
||||
|
||||
inline const char* kStreamToolUse = R"SSE(event: message_start
|
||||
data: {"type":"message_start","message":{"id":"msg_014p7gG3wDgGV9EUtLvnow3U","type":"message","role":"assistant","model":"claude-opus-5","stop_sequence":null,"usage":{"input_tokens":472,"output_tokens":2},"content":[],"stop_reason":null}}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
|
||||
|
||||
event: ping
|
||||
data: {"type": "ping"}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Okay"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":","}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" let"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"'s"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" check"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" the"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" weather"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" for"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" San"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Francisco"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":","}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" CA"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":":"}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type":"content_block_stop","index":0}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"toolu_01T1x1fJ34qAmk2tNTrN7Up6","name":"get_weather","input":{}}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":""}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\"location\":"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":" \"San"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":" Francisc"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"o,"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":" CA\"}"}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type":"content_block_stop","index":1}
|
||||
|
||||
event: message_delta
|
||||
data: {"type":"message_delta","delta":{"stop_reason":"tool_use","stop_sequence":null},"usage":{"output_tokens":89}}
|
||||
|
||||
event: message_stop
|
||||
data: {"type":"message_stop"}
|
||||
)SSE";
|
||||
|
||||
inline const char* kStreamThinking = R"SSE(event: message_start
|
||||
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-opus-5-5", "stop_reason": null, "stop_sequence": null}}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": "", "signature": ""}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "I need to find the GCD of 1071 and 462 using the Euclidean algorithm.\n\n1071 = 2 × 462 + 147"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n462 = 3 × 147 + 21"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n147 = 7 × 21 + 0"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\nThe remainder is 0, so GCD(1071, 462) = 21."}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type": "content_block_stop", "index": 0}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "The greatest common divisor of 1071 and 462 is **21**."}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type": "content_block_stop", "index": 1}
|
||||
|
||||
event: message_delta
|
||||
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
|
||||
|
||||
event: message_stop
|
||||
data: {"type": "message_stop"}
|
||||
)SSE";
|
||||
|
||||
inline const char* kStreamWebSearch = R"SSE(event: message_start
|
||||
data: {"type":"message_start","message":{"id":"msg_01G...","type":"message","role":"assistant","model":"claude-opus-5-5","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":2679,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"output_tokens":3}}}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"I'll check"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" the current weather in New York City for you"}}
|
||||
|
||||
event: ping
|
||||
data: {"type": "ping"}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"."}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type":"content_block_stop","index":0}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type":"content_block_start","index":1,"content_block":{"type":"server_tool_use","id":"srvtoolu_014hJH82Qum7Td6UV8gDXThB","name":"web_search","input":{}}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":""}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\"query"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"\":"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":" \"weather"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":" NY"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"C to"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"day\"}"}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type":"content_block_stop","index":1 }
|
||||
|
||||
event: content_block_start
|
||||
data: {"type":"content_block_start","index":2,"content_block":{"type":"web_search_tool_result","tool_use_id":"srvtoolu_014hJH82Qum7Td6UV8gDXThB","content":[{"type":"web_search_result","title":"Weather in New York City in May 2025 (New York) - detailed Weather Forecast for a month","url":"https://world-weather.info/forecast/usa/new_york/may-2025/","encrypted_content":"Ev0DCioIAxgCIiQ3NmU4ZmI4OC1k...","page_age":null},...]}}
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type":"content_block_stop","index":2}
|
||||
|
||||
event: content_block_start
|
||||
data: {"type":"content_block_start","index":3,"content_block":{"type":"text","text":""}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":3,"delta":{"type":"text_delta","text":"Here's the current weather information for New York"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":3,"delta":{"type":"text_delta","text":" City:\n\n# Weather"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":3,"delta":{"type":"text_delta","text":" in New York City"}}
|
||||
|
||||
event: content_block_delta
|
||||
data: {"type":"content_block_delta","index":3,"delta":{"type":"text_delta","text":"\n\n"}}
|
||||
|
||||
...
|
||||
|
||||
event: content_block_stop
|
||||
data: {"type":"content_block_stop","index":17}
|
||||
|
||||
event: message_delta
|
||||
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"input_tokens":10682,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"output_tokens":510,"server_tool_use":{"web_search_requests":1}}}
|
||||
|
||||
event: message_stop
|
||||
data: {"type":"message_stop"}
|
||||
)SSE";
|
||||
|
||||
// api/messages/create, Response (200), verbatim.
|
||||
inline const char* kMessageResponse = R"JSON({
|
||||
"id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
|
||||
"container": {
|
||||
"id": "container_011CpZohnwH4vuy7gazohgSP",
|
||||
"expires_at": "2019-12-27T18:11:19.117Z",
|
||||
"skills": [
|
||||
{
|
||||
"skill_id": "pdf",
|
||||
"type": "anthropic",
|
||||
"version": "latest"
|
||||
}
|
||||
]
|
||||
},
|
||||
"content": [
|
||||
{
|
||||
"citations": [
|
||||
{
|
||||
"cited_text": "The grass is green. The sky is blue.",
|
||||
"document_index": 0,
|
||||
"document_title": "My Document",
|
||||
"end_char_index": 0,
|
||||
"file_id": "file_011CNha8iCJcU1wXNR6q4V8w",
|
||||
"start_char_index": 0,
|
||||
"type": "char_location"
|
||||
}
|
||||
],
|
||||
"text": "Hi! My name is Claude.",
|
||||
"type": "text"
|
||||
}
|
||||
],
|
||||
"diagnostics": {
|
||||
"cache_miss_reason": {
|
||||
"cache_missed_input_tokens": 0,
|
||||
"type": "model_changed"
|
||||
}
|
||||
},
|
||||
"model": "claude-opus-5-5",
|
||||
"role": "assistant",
|
||||
"stop_details": {
|
||||
"category": "cyber",
|
||||
"explanation": "This request was declined because it conflicts with Anthropic's Usage Policy.",
|
||||
"type": "refusal"
|
||||
},
|
||||
"stop_reason": "end_turn",
|
||||
"stop_sequence": null,
|
||||
"type": "message",
|
||||
"usage": {
|
||||
"cache_creation": {
|
||||
"ephemeral_1h_input_tokens": 0,
|
||||
"ephemeral_5m_input_tokens": 0
|
||||
},
|
||||
"cache_creation_input_tokens": 2051,
|
||||
"cache_read_input_tokens": 2051,
|
||||
"inference_geo": "global",
|
||||
"input_tokens": 2095,
|
||||
"output_tokens": 503,
|
||||
"output_tokens_details": {
|
||||
"thinking_tokens": 0
|
||||
},
|
||||
"server_tool_use": {
|
||||
"web_fetch_requests": 2,
|
||||
"web_search_requests": 0
|
||||
},
|
||||
"service_tier": "standard",
|
||||
"speed": "standard"
|
||||
}
|
||||
})JSON";
|
||||
|
||||
// api/messages/batches_retrieve, Response (200), verbatim.
|
||||
inline const char* kBatchResponse = R"JSON({
|
||||
"id": "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
|
||||
"archived_at": "2024-08-20T18:37:24.100435Z",
|
||||
"cancel_initiated_at": "2024-08-20T18:37:24.100435Z",
|
||||
"created_at": "2024-08-20T18:37:24.100435Z",
|
||||
"ended_at": "2024-08-20T18:37:24.100435Z",
|
||||
"expires_at": "2024-08-20T18:37:24.100435Z",
|
||||
"processing_status": "in_progress",
|
||||
"request_counts": {
|
||||
"canceled": 10,
|
||||
"errored": 30,
|
||||
"expired": 10,
|
||||
"processing": 100,
|
||||
"succeeded": 50
|
||||
},
|
||||
"results_url": "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results",
|
||||
"type": "message_batch"
|
||||
})JSON";
|
||||
|
||||
// api/messages/count_tokens, Response (200), verbatim.
|
||||
inline const char* kCountTokensResponse = R"JSON({
|
||||
"input_tokens": 2095
|
||||
})JSON";
|
||||
|
||||
// api/models/retrieve, Response (200), verbatim.
|
||||
inline const char* kModelResponse = R"JSON({
|
||||
"id": "claude-opus-5-5",
|
||||
"capabilities": {
|
||||
"batch": {
|
||||
"supported": true
|
||||
},
|
||||
"citations": {
|
||||
"supported": true
|
||||
},
|
||||
"code_execution": {
|
||||
"supported": true
|
||||
},
|
||||
"context_management": {
|
||||
"clear_thinking_20251015": {
|
||||
"supported": true
|
||||
},
|
||||
"clear_tool_uses_20250919": {
|
||||
"supported": true
|
||||
},
|
||||
"compact_20260112": {
|
||||
"supported": true
|
||||
},
|
||||
"supported": true
|
||||
},
|
||||
"effort": {
|
||||
"high": {
|
||||
"supported": true
|
||||
},
|
||||
"low": {
|
||||
"supported": true
|
||||
},
|
||||
"max": {
|
||||
"supported": true
|
||||
},
|
||||
"medium": {
|
||||
"supported": true
|
||||
},
|
||||
"supported": true,
|
||||
"xhigh": {
|
||||
"supported": true
|
||||
}
|
||||
},
|
||||
"image_input": {
|
||||
"supported": true
|
||||
},
|
||||
"pdf_input": {
|
||||
"supported": true
|
||||
},
|
||||
"server_tools": {
|
||||
"code_execution": {
|
||||
"supported": true
|
||||
},
|
||||
"supported": true,
|
||||
"web_search": {
|
||||
"supported": true
|
||||
}
|
||||
},
|
||||
"structured_outputs": {
|
||||
"supported": true
|
||||
},
|
||||
"thinking": {
|
||||
"supported": true,
|
||||
"types": {
|
||||
"adaptive": {
|
||||
"supported": true
|
||||
},
|
||||
"between_tools": {
|
||||
"supported": true
|
||||
},
|
||||
"disabled": {
|
||||
"supported": true
|
||||
},
|
||||
"enabled": {
|
||||
"supported": true
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"created_at": "2026-09-21T00:00:00Z",
|
||||
"deprecated_at": "2019-12-27T18:11:19.117Z",
|
||||
"display_name": "Claude Opus 5.5",
|
||||
"lifecycle": "active",
|
||||
"line": "haiku",
|
||||
"max_input_tokens": 0,
|
||||
"max_tokens": 0,
|
||||
"retires_at": "2019-12-27T18:11:19.117Z",
|
||||
"type": "model"
|
||||
})JSON";
|
||||
|
||||
// api/files/retrieve_metadata, Response (200), verbatim.
|
||||
inline const char* kFileResponse = R"JSON({
|
||||
"id": "file_011CNha8iCJcU1wXNR6q4V8w",
|
||||
"created_at": "2025-04-15T18:37:24.100435Z",
|
||||
"filename": "document.pdf",
|
||||
"mime_type": "application/pdf",
|
||||
"size_bytes": 102400,
|
||||
"type": "file",
|
||||
"downloadable": false,
|
||||
"expires_at": "2025-05-15T18:37:24.100435Z"
|
||||
})JSON";
|
||||
|
||||
// api/skills/versions_retrieve, Response (200), verbatim.
|
||||
inline const char* kSkillVersionResponse = R"JSON({
|
||||
"id": "id",
|
||||
"created_at": "2024-10-30T23:58:27.427722Z",
|
||||
"description": "description",
|
||||
"name": "name",
|
||||
"skill_id": "skill_01JAbcdefghijklmnopqrstuvw",
|
||||
"type": "skill_version"
|
||||
})JSON";
|
||||
|
||||
// api/errors, "Error shapes" (verbatim).
|
||||
inline const char* kErrorBody = R"JSON({
|
||||
"type": "error",
|
||||
"error": {
|
||||
"type": "not_found_error",
|
||||
"message": "The requested resource could not be found."
|
||||
},
|
||||
"request_id": "req_011CSHoEeqs5C35K2UUqR7Fy"
|
||||
})JSON";
|
||||
|
||||
// streaming, "Error events" (verbatim).
|
||||
inline const char* kStreamError = R"SSE(event: error
|
||||
data: {"type": "error", "error": {"type": "overloaded_error", "message": "Overloaded"}}
|
||||
|
||||
)SSE";
|
||||
|
||||
} // namespace anthropic_fixtures
|
||||
@@ -0,0 +1,52 @@
|
||||
#pragma once
|
||||
|
||||
// Test rig: a Session over MockTransport. The mock only records the requests
|
||||
// the module builds and returns documented fixture bodies (see fixtures.h);
|
||||
// no vendor behaviour is invented.
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "anthropic/core/anthropic.h"
|
||||
#include "clients/transports/mock_transport.h"
|
||||
#include "framework.h"
|
||||
|
||||
namespace anthropic_test {
|
||||
|
||||
using namespace molo::anthropic::core;
|
||||
using molo::clients::ClientResponse;
|
||||
using molo::clients::HeaderMap;
|
||||
using molo::clients::Method;
|
||||
using molo::clients::transports::MockTransport;
|
||||
|
||||
inline ClientResponse reply(const std::string& body, int status = 200,
|
||||
const std::string& type = "application/json") {
|
||||
HeaderMap h;
|
||||
h.set("Content-Type", type);
|
||||
h.set("request-id", "req_test");
|
||||
return ClientResponse(status, h, body);
|
||||
}
|
||||
|
||||
struct Rig {
|
||||
MockTransport* mock = nullptr;
|
||||
std::shared_ptr<Session> session;
|
||||
std::unique_ptr<Anthropic> api;
|
||||
|
||||
explicit Rig(const std::string& key = "sk-ant-test-KEY", SessionOptions options = {}) {
|
||||
auto t = std::make_unique<MockTransport>();
|
||||
mock = t.get();
|
||||
session = Session::with_transport(std::move(t), key, std::move(options));
|
||||
api = std::make_unique<Anthropic>(session);
|
||||
}
|
||||
MockTransport::SeenRequest last() const { return mock->seen().back(); }
|
||||
};
|
||||
|
||||
inline MessageRequest hello(const std::string& model = "claude-opus-5-5") {
|
||||
MessageRequest r;
|
||||
r.model = model;
|
||||
r.set_max_tokens(256);
|
||||
r.add(MessageParam::user("Hello"));
|
||||
return r;
|
||||
}
|
||||
|
||||
} // namespace anthropic_test
|
||||
@@ -0,0 +1,221 @@
|
||||
// AnthropicChatModel mapping plus the opt-in live checks (MOLO_LIVE_NET=1;
|
||||
// anything that spends money also needs MOLO_LIVE_PAID=1; a key comes from
|
||||
// ANTHROPIC_API_KEY through llm::Config). No key: loud SKIP.
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "fixtures.h"
|
||||
#include "clients/transports/http_transport.h"
|
||||
#include "llm/config.h"
|
||||
#include "rig.h"
|
||||
|
||||
using namespace anthropic_test;
|
||||
namespace fx = anthropic_fixtures;
|
||||
namespace llm = molo::llm;
|
||||
|
||||
namespace {
|
||||
bool rejects(const std::function<void()>& f) {
|
||||
try {
|
||||
f();
|
||||
} catch (const llm::ApiError&) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(anthropic_chat, neutral_request_maps_to_messages_request) {
|
||||
Rig r;
|
||||
auto model = r.api->chat_model("claude-sonnet-5-5", 1000);
|
||||
llm::ChatRequest in;
|
||||
in.system = "Be brief.";
|
||||
in.messages.push_back(llm::Message::system("Speak French."));
|
||||
in.messages.push_back(llm::Message::user("Weather?"));
|
||||
llm::Message asst;
|
||||
asst.role = llm::Role::kAssistant;
|
||||
llm::ContentPart th;
|
||||
th.reasoning = "thinking...";
|
||||
th.reasoning_signature = "SIG==";
|
||||
asst.parts.push_back(th);
|
||||
asst.parts.push_back(llm::ContentPart::of_call({"toolu_1", "get_weather", Json::parse(R"({"city":"Oslo"})")}));
|
||||
in.messages.push_back(asst);
|
||||
llm::Message tool;
|
||||
tool.role = llm::Role::kTool;
|
||||
tool.parts.push_back(llm::ContentPart::of_result({"toolu_1", "12C", false}));
|
||||
in.messages.push_back(tool);
|
||||
in.tools.push_back({"get_weather", "Weather", Json::parse(R"({"type":"object"})")});
|
||||
in.tool_choice = "required";
|
||||
in.stop = {"END"};
|
||||
in.reasoning_effort = "high";
|
||||
in.response_schema = Json::parse(R"({"type":"object","properties":{}})");
|
||||
in.extra = Json::parse(R"({"betas":["interleaved-thinking-2025-05-14"],"thinking":{"type":"enabled","budget_tokens":2048}})");
|
||||
in.max_tokens = 4000;
|
||||
MessageRequest m = model->to_message_request(in);
|
||||
m.validate(ApiVersion::k20230601);
|
||||
Json j = m.to_json(false, ApiVersion::k20230601);
|
||||
ASSERT_EQ(j.find("model")->as_string(), "claude-sonnet-5-5");
|
||||
ASSERT_EQ(j.find("system")->as_string(), "Be brief.\n\nSpeak French.");
|
||||
ASSERT_EQ(j.find("messages")->as_array().size(), 3u);
|
||||
const Json& a = j.find("messages")->as_array()[1];
|
||||
ASSERT_EQ(a.find("content")->as_array()[0].find("type")->as_string(), "thinking");
|
||||
ASSERT_EQ(a.find("content")->as_array()[0].find("signature")->as_string(), "SIG==");
|
||||
ASSERT_EQ(a.find("content")->as_array()[1].find("type")->as_string(), "tool_use");
|
||||
const Json& t = j.find("messages")->as_array()[2];
|
||||
ASSERT_EQ(t.find("role")->as_string(), "user");
|
||||
ASSERT_EQ(t.find("content")->as_array()[0].find("type")->as_string(), "tool_result");
|
||||
ASSERT_EQ(j.find("tool_choice")->find("type")->as_string(), "any");
|
||||
ASSERT_EQ(j.find("output_config")->find("effort")->as_string(), "high");
|
||||
ASSERT_EQ(j.find("thinking")->find("budget_tokens")->as_int(), 2048);
|
||||
ASSERT_TRUE(m.effective_betas().contains(Beta::kInterleavedThinking20250514));
|
||||
// default max_tokens
|
||||
llm::ChatRequest min;
|
||||
min.messages.push_back(llm::Message::user("hi"));
|
||||
ASSERT_EQ(model->to_message_request(min).max_tokens, 1000);
|
||||
// json_mode without a schema, and sampling under 2026-10-21, are loud
|
||||
llm::ChatRequest jm = min;
|
||||
jm.json_mode = true;
|
||||
ASSERT_TRUE(rejects([&] { model->to_message_request(jm); }));
|
||||
llm::ChatRequest temp = min;
|
||||
temp.temperature = 0.2;
|
||||
MessageRequest tm = model->to_message_request(temp);
|
||||
ASSERT_TRUE(rejects([&] { tm.validate(ApiVersion::k20261021); }));
|
||||
}
|
||||
|
||||
TEST(anthropic_chat, generate_maps_response_thinking_tools_and_usage) {
|
||||
Rig r;
|
||||
auto model = r.api->chat_model("claude-opus-5-5");
|
||||
std::string resp = R"({"id":"msg_1","type":"message","role":"assistant","model":"claude-opus-5-5","content":[
|
||||
{"type":"thinking","thinking":"hmm","signature":"SIGN"},
|
||||
{"type":"redacted_thinking","data":"ENC"},
|
||||
{"type":"text","text":"Checking."},
|
||||
{"type":"tool_use","id":"toolu_9","name":"get_weather","input":{"city":"Oslo"}}],
|
||||
"stop_reason":"tool_use","stop_sequence":null,
|
||||
"usage":{"input_tokens":10,"output_tokens":20,"cache_read_input_tokens":4,"output_tokens_details":{"thinking_tokens":7}}})";
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(resp));
|
||||
llm::ChatRequest in;
|
||||
in.messages.push_back(llm::Message::user("weather in Oslo"));
|
||||
llm::ChatResponse out = model->generate(in);
|
||||
ASSERT_EQ(out.text(), "Checking.");
|
||||
ASSERT_EQ(out.finish_reason, "tool_calls");
|
||||
ASSERT_EQ(out.tool_calls().size(), 1u);
|
||||
ASSERT_EQ(out.tool_calls()[0].id, "toolu_9");
|
||||
ASSERT_EQ(out.message.parts[0].reasoning, "hmm");
|
||||
ASSERT_EQ(out.message.parts[0].reasoning_signature, "SIGN");
|
||||
ASSERT_EQ(out.message.parts[1].reasoning_signature, "redacted_thinking:ENC");
|
||||
ASSERT_EQ(out.usage.cached_tokens, 4);
|
||||
ASSERT_EQ(out.usage.reasoning_tokens, 7);
|
||||
ASSERT_EQ(out.usage.total_tokens, 30);
|
||||
// Round trip: the neutral assistant message replays signature and redacted data.
|
||||
llm::ChatRequest next = in;
|
||||
next.messages.push_back(out.message);
|
||||
llm::Message res;
|
||||
res.role = llm::Role::kTool;
|
||||
res.parts.push_back(llm::ContentPart::of_result({"toolu_9", "12C", false}));
|
||||
next.messages.push_back(res);
|
||||
Json j = model->to_message_request(next).to_json(false, ApiVersion::k20230601);
|
||||
const auto& content = j.find("messages")->as_array()[1].find("content")->as_array();
|
||||
ASSERT_EQ(content[0].find("signature")->as_string(), "SIGN");
|
||||
ASSERT_EQ(content[1].find("type")->as_string(), "redacted_thinking");
|
||||
ASSERT_EQ(content[1].find("data")->as_string(), "ENC");
|
||||
ASSERT_EQ(finish_reason_of(StopReason::kRefusal), "content_filter");
|
||||
ASSERT_EQ(finish_reason_of(StopReason::kMaxTokens), "length");
|
||||
ASSERT_EQ(model->vendor(), "anthropic");
|
||||
}
|
||||
|
||||
TEST(anthropic_chat, stream_emits_text_reasoning_tool_fragments_and_usage) {
|
||||
Rig r;
|
||||
auto model = r.api->chat_model("claude-opus-5-5");
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamToolUse, 200, "text/event-stream"));
|
||||
llm::ChatRequest in;
|
||||
in.messages.push_back(llm::Message::user("weather"));
|
||||
std::string text, args, name, finish;
|
||||
int total = 0;
|
||||
model->stream(in, [&](const llm::ChatChunk& c) {
|
||||
text += c.text_delta;
|
||||
args += c.tool_args_delta;
|
||||
if (!c.tool_call_name.empty()) name = c.tool_call_name;
|
||||
if (!c.finish_reason.empty()) finish = c.finish_reason;
|
||||
if (c.usage) total = c.usage->output_tokens;
|
||||
return true;
|
||||
});
|
||||
ASSERT_TRUE(text.find("Okay, let's check the") == 0);
|
||||
ASSERT_FALSE(name.empty());
|
||||
ASSERT_TRUE(Json::parse(args).has("location"));
|
||||
ASSERT_EQ(finish, "tool_calls");
|
||||
ASSERT_EQ(total, 89);
|
||||
ASSERT_EQ(model->last_stream_message().tool_uses().size(), 1u);
|
||||
Rig t;
|
||||
auto tm = t.api->chat_model("claude-opus-5-5");
|
||||
t.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamThinking, 200, "text/event-stream"));
|
||||
std::string reasoning;
|
||||
tm->stream(in, [&](const llm::ChatChunk& c) {
|
||||
reasoning += c.reasoning_delta;
|
||||
return true;
|
||||
});
|
||||
ASSERT_TRUE(reasoning.find("Euclidean") != std::string::npos);
|
||||
ASSERT_EQ(tm->last_stream_message().content[0].signature().substr(0, 4), "EqQB");
|
||||
}
|
||||
|
||||
// --- opt-in live checks ---------------------------------------------------------------
|
||||
|
||||
namespace {
|
||||
bool live_net() {
|
||||
const char* v = std::getenv("MOLO_LIVE_NET");
|
||||
return v && std::string(v) == "1";
|
||||
}
|
||||
bool live_paid() {
|
||||
const char* v = std::getenv("MOLO_LIVE_PAID");
|
||||
return v && std::string(v) == "1";
|
||||
}
|
||||
} // namespace
|
||||
|
||||
// Unauthenticated probe: the host resolves, TLS works, a documented path
|
||||
// answers 401 authentication_error with the documented envelope and a request id.
|
||||
TEST(anthropic_live, unauthenticated_probe_answers_401_with_documented_envelope) {
|
||||
if (!live_net()) {
|
||||
std::cout << "SKIP anthropic_live.unauthenticated_probe (set MOLO_LIVE_NET=1)\n";
|
||||
return;
|
||||
}
|
||||
auto session = Session::with_transport(std::make_unique<molo::clients::transports::HttpTransport>(), "invalid-key-for-probe");
|
||||
Models models(session);
|
||||
try {
|
||||
models.list();
|
||||
FAIL("expected 401");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_EQ(e.http_status(), 401);
|
||||
ASSERT_TRUE(e.kind() == ErrorKind::kAuthentication);
|
||||
ASSERT_FALSE(e.request_id().empty());
|
||||
}
|
||||
// The key must never be echoed anywhere.
|
||||
}
|
||||
|
||||
TEST(anthropic_live, read_only_models_and_count_tokens_with_a_key) {
|
||||
if (!live_net() || llm::Config::get("ANTHROPIC_API_KEY").empty()) {
|
||||
std::cout << "SKIP anthropic_live.read_only (set MOLO_LIVE_NET=1 and ANTHROPIC_API_KEY)\n";
|
||||
return;
|
||||
}
|
||||
Anthropic api = Anthropic::from_env();
|
||||
Page p = api.models->list(5);
|
||||
ASSERT_FALSE(p.data.empty());
|
||||
ModelInfo first = ModelInfo::parse(p.data[0]);
|
||||
ModelInfo again = api.models->retrieve(first.id);
|
||||
ASSERT_EQ(again.id, first.id);
|
||||
MessageRequest r = hello(first.id);
|
||||
ASSERT_TRUE(api.messages->count_tokens(r).input_tokens > 0);
|
||||
api.batches->list(1);
|
||||
api.files->list(1);
|
||||
}
|
||||
|
||||
TEST(anthropic_live, one_smallest_completion_is_paid) {
|
||||
if (!live_net() || !live_paid() || llm::Config::get("ANTHROPIC_API_KEY").empty()) {
|
||||
std::cout << "SKIP anthropic_live.one_completion (set MOLO_LIVE_NET=1, MOLO_LIVE_PAID=1 and ANTHROPIC_API_KEY)\n";
|
||||
return;
|
||||
}
|
||||
Anthropic api = Anthropic::from_env();
|
||||
Page p = api.models->list(1);
|
||||
ASSERT_FALSE(p.data.empty());
|
||||
MessageRequest r = hello(ModelInfo::parse(p.data[0]).id);
|
||||
r.set_max_tokens(8);
|
||||
MessageResult res = api.messages->create(r);
|
||||
ASSERT_FALSE(res.message.id.empty());
|
||||
}
|
||||
@@ -0,0 +1,276 @@
|
||||
// Anthropic core: versions, betas, call table, errors, content blocks, tools,
|
||||
// options and request building. Local only: no network, no scripted vendor logic.
|
||||
#include "rig.h"
|
||||
|
||||
using namespace anthropic_test;
|
||||
|
||||
namespace {
|
||||
bool throws_invalid(const std::function<void()>& f) {
|
||||
try {
|
||||
f();
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
return e.type() == "INVALID_ARGUMENT";
|
||||
}
|
||||
return false;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(anthropic_model, versions_and_sampling_rules) {
|
||||
ASSERT_EQ(std::string(version_name(ApiVersion::k20230601)), "2023-06-01");
|
||||
ASSERT_EQ(std::string(version_name(ApiVersion::k20261021)), "2026-10-21");
|
||||
ASSERT_TRUE(parse_version("2026-10-21") == ApiVersion::k20261021);
|
||||
ASSERT_TRUE(throws_invalid([] { parse_version("2024-01-01"); }));
|
||||
MessageRequest r = hello();
|
||||
r.temperature = 0.5;
|
||||
r.validate(ApiVersion::k20230601);
|
||||
ASSERT_TRUE(r.to_json(false, ApiVersion::k20230601).has("temperature"));
|
||||
ASSERT_TRUE(throws_invalid([&] { r.validate(ApiVersion::k20261021); }));
|
||||
r.temperature = 1.5;
|
||||
ASSERT_TRUE(throws_invalid([&] { r.validate(ApiVersion::k20230601); }));
|
||||
}
|
||||
|
||||
TEST(anthropic_model, version_rules_for_documents_and_citations) {
|
||||
MessageRequest r = hello();
|
||||
r.add(MessageParam::assistant({ContentBlock::document_text("x")}));
|
||||
r.validate(ApiVersion::k20230601);
|
||||
ASSERT_TRUE(throws_invalid([&] { r.validate(ApiVersion::k20261021); }));
|
||||
MessageRequest c = hello();
|
||||
ContentBlock t = ContentBlock::from_json(Json::parse(R"({"type":"text","text":"a","citations":[{"type":"char_location","cited_text":"a","document_index":0,"document_title":null,"start_char_index":0,"end_char_index":1}]})"));
|
||||
c.messages.clear();
|
||||
c.add(MessageParam::user({t}));
|
||||
c.validate(ApiVersion::k20230601);
|
||||
ASSERT_TRUE(throws_invalid([&] { c.validate(ApiVersion::k20261021); }));
|
||||
}
|
||||
|
||||
TEST(anthropic_model, beta_table_is_typed_and_never_drops) {
|
||||
ASSERT_EQ(beta_count(), 55u);
|
||||
ASSERT_EQ(std::string(beta_name(Beta::kInterleavedThinking20250514)), "interleaved-thinking-2025-05-14");
|
||||
ASSERT_TRUE(find_beta("fast-mode-2026-02-01").has_value());
|
||||
ASSERT_FALSE(find_beta("nope-2030-01-01").has_value());
|
||||
BetaSet s;
|
||||
s.add(Beta::kFilesApi20250414).add(Beta::kFilesApi20250414).add_name("brand-new-2030-01-01");
|
||||
ASSERT_EQ(s.size(), 2u);
|
||||
ASSERT_EQ(s.header_value(), "files-api-2025-04-14,brand-new-2030-01-01");
|
||||
ASSERT_EQ(s.unknown().size(), 1u);
|
||||
ASSERT_TRUE(throws_invalid([&] { s.add_name("Bad Name"); }));
|
||||
ASSERT_TRUE(throws_invalid([&] { s.add_name("-x"); }));
|
||||
BetaSet big;
|
||||
for (int i = 0; i < 32; ++i) big.add_name("b-" + std::to_string(i));
|
||||
ASSERT_TRUE(throws_invalid([&] { big.add_name("one-more"); }));
|
||||
}
|
||||
|
||||
TEST(anthropic_model, call_table_renders_validated_paths) {
|
||||
ASSERT_EQ(call_count(), 32u);
|
||||
ASSERT_EQ(render(Call::kMessagesCreate), "/v1/messages");
|
||||
ASSERT_EQ(render(Call::kBatchesResults, "msgbatch_01"), "/v1/messages/batches/msgbatch_01/results");
|
||||
ASSERT_EQ(render(Call::kSkillVersionsDownload, "skill_1", "latest"), "/v1/skills/skill_1/versions/latest/content");
|
||||
ASSERT_TRUE(throws_invalid([] { render(Call::kBatchesRetrieve, "../x"); }));
|
||||
ASSERT_TRUE(throws_invalid([] { render(Call::kBatchesRetrieve, ""); }));
|
||||
ASSERT_TRUE(throws_invalid([] { render(Call::kFilesDelete, "a/b"); }));
|
||||
ASSERT_TRUE(method_of(Call::kBatchesDelete) == Method::kDelete);
|
||||
for (std::size_t i = 0; i < call_count(); ++i) {
|
||||
const CallSpec& s = spec_at(i);
|
||||
ASSERT_TRUE(std::string(s.path).rfind("/v1/", 0) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(anthropic_model, error_taxonomy_and_rate_limit_headers) {
|
||||
ASSERT_TRUE(classify_error("rate_limit_error", 429) == ErrorKind::kRateLimit);
|
||||
ASSERT_TRUE(classify_error("something_new", 529) == ErrorKind::kOverloaded);
|
||||
ASSERT_TRUE(classify_error("", 418) == ErrorKind::kInvalidRequest);
|
||||
ASSERT_TRUE(classify_error("", 503) == ErrorKind::kApi);
|
||||
ASSERT_EQ(error_kind_count(), 15u);
|
||||
HeaderMap h;
|
||||
h.set("anthropic-ratelimit-requests-limit", "50");
|
||||
h.set("anthropic-ratelimit-requests-remaining", "49");
|
||||
h.set("anthropic-ratelimit-requests-reset", "2026-10-24T10:00:00Z");
|
||||
h.set("anthropic-ratelimit-output-tokens-remaining", "8000");
|
||||
h.set("anthropic-priority-input-tokens-limit", "10000");
|
||||
h.set("retry-after", "12");
|
||||
h.set("x-should-retry", "true");
|
||||
h.set("request-id", "req_1");
|
||||
RateLimits r = parse_rate_limits(h);
|
||||
ASSERT_EQ(*r.requests.limit, 50);
|
||||
ASSERT_EQ(*r.requests.remaining, 49);
|
||||
ASSERT_EQ(r.requests.reset, "2026-10-24T10:00:00Z");
|
||||
ASSERT_EQ(*r.output_tokens.remaining, 8000);
|
||||
ASSERT_EQ(*r.priority_input_tokens.limit, 10000);
|
||||
ASSERT_TRUE(!r.tokens.present());
|
||||
ASSERT_EQ(*r.retry_after_seconds, 12.0);
|
||||
ASSERT_TRUE(*r.should_retry);
|
||||
ASSERT_EQ(r.request_id, "req_1");
|
||||
HeaderMap ms;
|
||||
ms.set("retry-after-ms", "1500");
|
||||
ASSERT_EQ(*parse_rate_limits(ms).retry_after_seconds, 1.5);
|
||||
ASSERT_FALSE(parse_rate_limits(HeaderMap{}).any());
|
||||
}
|
||||
|
||||
TEST(anthropic_model, content_blocks_validate_against_the_schema_table) {
|
||||
ASSERT_EQ(ContentBlock::text("hi").json().dump(), R"({"text":"hi","type":"text"})");
|
||||
ContentBlock img = ContentBlock::image_base64("image/png", "AAAA");
|
||||
ASSERT_EQ(img.json().find("source")->find("media_type")->as_string(), "image/png");
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::image_base64("image/bmp", "AAAA"); }));
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::image_url("ftp://x"); }));
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::image_file("a/b"); }));
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::from_json(Json::parse(R"({"type":"text","text":"a","bogus":1})")); }));
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::from_json(Json::parse(R"({"type":"text"})")); }));
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::from_json(Json::parse(R"({"type":"nope"})")); }));
|
||||
ContentBlock doc = ContentBlock::document_pdf_base64("JVBERi0=");
|
||||
doc.citations_enabled().title("t").context("c").cache(CacheControl::one_hour());
|
||||
ASSERT_EQ(doc.json().find("cache_control")->find("ttl")->as_string(), "1h");
|
||||
ASSERT_TRUE(throws_invalid([&] { ContentBlock::text("x").title("t"); }));
|
||||
ContentBlock tr = ContentBlock::tool_result("toolu_01", "259.75 USD", true);
|
||||
ASSERT_TRUE(tr.json().find("is_error")->as_bool());
|
||||
ASSERT_TRUE(throws_invalid([] { ContentBlock::tool_result("bad id", "x"); }));
|
||||
ContentBlock sr = ContentBlock::search_result("https://e.x", "T", {ContentBlock::text("body")});
|
||||
ASSERT_EQ(sr.type(), "search_result");
|
||||
// Echoed response blocks keep unknown fields and new types.
|
||||
ContentBlock echo = ContentBlock::from_json(Json::parse(R"({"type":"future_block","x":1})"), true);
|
||||
ASSERT_EQ(echo.json().dump(), R"({"type":"future_block","x":1})");
|
||||
ASSERT_TRUE(throws_invalid([] { CacheControl::from_json(Json::parse(R"({"type":"ephemeral","ttl":"2h"})")); }));
|
||||
ASSERT_EQ(block_schema_count(), 24u);
|
||||
}
|
||||
|
||||
TEST(anthropic_model, tools_cover_every_documented_type) {
|
||||
ASSERT_EQ(tool_schema_count(), 30u);
|
||||
Tool t = Tool::custom("get_weather", "Weather", Json::parse(R"({"type":"object","properties":{}})"));
|
||||
t.strict().defer_loading().cache(CacheControl::five_minutes());
|
||||
ASSERT_EQ(t.json().find("strict")->as_bool(), true);
|
||||
ASSERT_TRUE(throws_invalid([] { Tool::custom("bad name!", "", Json::object()); }));
|
||||
Tool ws = Tool::builtin("web_search_20260318", Json::parse(R"({"max_uses":3,"allowed_domains":["a.com"],"user_location":{"type":"approximate","city":"Oslo"}})"));
|
||||
ASSERT_EQ(ws.name(), "web_search");
|
||||
ASSERT_TRUE(ws.required_betas().empty());
|
||||
ASSERT_TRUE(throws_invalid([] { Tool::builtin("web_search_20250305", Json::parse(R"({"response_inclusion":"full"})")); }));
|
||||
ASSERT_TRUE(throws_invalid([] { Tool::builtin("not_a_tool"); }));
|
||||
ASSERT_TRUE(throws_invalid([] { Tool::builtin("computer_20251124"); })); // needs the display size
|
||||
ASSERT_EQ(Tool::computer(1024, 768).required_betas().header_value(), "computer-use-2025-11-24");
|
||||
ASSERT_EQ(Tool::advisor("claude-opus-5-5").required_betas().header_value(), "advisor-tool-2026-03-01");
|
||||
ASSERT_EQ(Tool::mcp_toolset("srv").required_betas().header_value(), "mcp-client-2025-11-20");
|
||||
ASSERT_EQ(Tool::builtin("bash_20241022").required_betas().header_value(), "computer-use-2024-10-22");
|
||||
ASSERT_EQ(Tool::builtin("code_execution_20250522").required_betas().header_value(), "code-execution-2025-05-22");
|
||||
ASSERT_TRUE(Tool::memory().name() == "memory");
|
||||
ASSERT_EQ(Tool::text_editor().name(), "str_replace_based_edit_tool");
|
||||
ASSERT_TRUE(Tool::browser_toolset().json().find("name") == nullptr);
|
||||
ASSERT_TRUE(throws_invalid([] { Tool::computer_toolset().strict(); }));
|
||||
ASSERT_TRUE(throws_invalid([] { Tool::builtin("computer_toolset_20260801", Json::parse(R"({"allowed_callers":["code_execution_20260120"]})")); }));
|
||||
Tool pinned = Tool::builtin("mcp_toolset", Json::parse(R"({"mcp_server_name":"s","tools":[]})"));
|
||||
ASSERT_TRUE(pinned.required_betas().contains(Beta::kMcpClient20260915));
|
||||
ASSERT_EQ(ToolChoice::tool("x").to_json().dump(), R"({"name":"x","type":"tool"})");
|
||||
ToolChoice a = ToolChoice::any();
|
||||
a.disable_parallel = true;
|
||||
ASSERT_EQ(a.to_json().dump(), R"({"disable_parallel_tool_use":true,"type":"any"})");
|
||||
ASSERT_EQ(ToolChoice::none().to_json().dump(), R"({"type":"none"})");
|
||||
}
|
||||
|
||||
TEST(anthropic_model, options_thinking_output_context) {
|
||||
ASSERT_TRUE(throws_invalid([] { ThinkingConfig::enabled(512).validate(4096); }));
|
||||
ASSERT_TRUE(throws_invalid([] { ThinkingConfig::enabled(4096).validate(4096); }));
|
||||
ThinkingConfig::enabled(2048).validate(4096);
|
||||
ASSERT_EQ(ThinkingConfig::adaptive().with_display(ThinkingConfig::Display::kSummarized).to_json().dump(),
|
||||
R"({"display":"summarized","type":"adaptive"})");
|
||||
ASSERT_TRUE(ThinkingConfig::adaptive().with_display(ThinkingConfig::Display::kUpdates).required_betas().contains(Beta::kThinkingDisplayUpdates20260818));
|
||||
ASSERT_TRUE(throws_invalid([] { ThinkingConfig::disabled().with_display(ThinkingConfig::Display::kOmitted).validate(100); }));
|
||||
OutputConfig oc;
|
||||
oc.effort = "xhigh";
|
||||
oc.format = Json::parse(R"({"type":"object"})");
|
||||
oc.task_budget_total = 20000;
|
||||
ASSERT_EQ(oc.to_json().find("format")->find("type")->as_string(), "json_schema");
|
||||
ASSERT_TRUE(oc.required_betas().contains(Beta::kTaskBudgets20260313));
|
||||
oc.effort = "ultra";
|
||||
ASSERT_TRUE(throws_invalid([&] { oc.validate(); }));
|
||||
ContextManagement cm;
|
||||
cm.edits.push_back(ContextEdit::clear_tool_uses());
|
||||
cm.edits.push_back(ContextEdit::compact());
|
||||
ASSERT_TRUE(cm.required_betas().contains(Beta::kContextManagement20250627));
|
||||
ASSERT_TRUE(cm.required_betas().contains(Beta::kCompact20260112));
|
||||
ASSERT_TRUE(throws_invalid([] { ContextManagement{}.validate(); }));
|
||||
Container c;
|
||||
c.id = "container_01";
|
||||
ASSERT_TRUE(c.to_json().is_string());
|
||||
c.skills.push_back({"anthropic", "pptx", "latest"});
|
||||
ASSERT_EQ(c.to_json().find("skills")->as_array().size(), 1u);
|
||||
c.skills[0].type = "other";
|
||||
ASSERT_TRUE(throws_invalid([&] { c.validate(); }));
|
||||
McpServer s;
|
||||
s.name = "srv";
|
||||
s.url = "http://insecure";
|
||||
ASSERT_TRUE(throws_invalid([&] { s.validate(); }));
|
||||
}
|
||||
|
||||
TEST(anthropic_model, request_body_and_derived_betas) {
|
||||
MessageRequest r = hello();
|
||||
r.set_max_tokens(4096);
|
||||
r.system_text = "Be brief.";
|
||||
r.add_tool(Tool::web_search(2));
|
||||
r.add_tool(Tool::advisor("claude-opus-5-5"));
|
||||
r.thinking = ThinkingConfig::enabled(2000);
|
||||
r.stop_sequences = {"END"};
|
||||
r.metadata_user_id = "u-1";
|
||||
r.service_tier = ServiceTier::kStandardOnly;
|
||||
r.cache_control = CacheControl::one_hour();
|
||||
r.compaction = CompactionConfig{"keep names"};
|
||||
r.betas.add(Beta::kInterleavedThinking20250514);
|
||||
r.validate(ApiVersion::k20230601);
|
||||
Json j = r.to_json(true, ApiVersion::k20230601);
|
||||
ASSERT_TRUE(j.find("stream")->as_bool());
|
||||
ASSERT_EQ(j.find("system")->as_string(), "Be brief.");
|
||||
ASSERT_EQ(j.find("service_tier")->as_string(), "standard_only");
|
||||
ASSERT_EQ(j.find("metadata")->find("user_id")->as_string(), "u-1");
|
||||
ASSERT_EQ(j.find("tools")->as_array().size(), 2u);
|
||||
BetaSet e = r.effective_betas();
|
||||
ASSERT_TRUE(e.contains(Beta::kAdvisorTool20260301));
|
||||
ASSERT_TRUE(e.contains(Beta::kCompact20260904));
|
||||
ASSERT_TRUE(e.contains(Beta::kInterleavedThinking20250514));
|
||||
Json ct = r.to_count_tokens_json(ApiVersion::k20230601);
|
||||
ASSERT_TRUE(ct.find("max_tokens") == nullptr);
|
||||
ASSERT_TRUE(ct.find("stop_sequences") == nullptr);
|
||||
ASSERT_TRUE(ct.has("tools"));
|
||||
}
|
||||
|
||||
TEST(anthropic_model, request_validation_rules) {
|
||||
auto bad_req = [](const std::function<void(MessageRequest&)>& mut) {
|
||||
MessageRequest r = hello();
|
||||
mut(r);
|
||||
return throws_invalid([&] { r.validate(ApiVersion::k20230601); });
|
||||
};
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.model = ""; }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.messages.clear(); }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.max_tokens = -1; }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.speed = "turbo"; }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.tool_choice = ToolChoice::any(); })); // no tools
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.add_tool(Tool::web_search()); r.add_tool(Tool::web_search()); }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.mcp_servers.push_back({"s", "https://m.x", "", {}, std::nullopt}); }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.extra.set("model", Json("x")); }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.fallbacks_default = true; r.fallbacks.push_back({"m", std::nullopt, ""}); }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.thread_type = "continue"; }));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) {
|
||||
for (int i = 0; i < 5; ++i)
|
||||
r.messages.push_back(MessageParam::user({ContentBlock::text("x").cache(CacheControl::default_ttl())}));
|
||||
}));
|
||||
ASSERT_TRUE(bad_req([](MessageRequest& r) { r.add(MessageParam::user({ContentBlock::thinking("a", "sig")})); }));
|
||||
// max_tokens 0 pre-warms the cache and is valid.
|
||||
MessageRequest zero = hello();
|
||||
zero.set_max_tokens(0);
|
||||
zero.validate(ApiVersion::k20230601);
|
||||
MessageRequest mcp = hello();
|
||||
mcp.mcp_servers.push_back({"s", "https://m.x", "tok", {"a"}, true});
|
||||
mcp.add_tool(Tool::mcp_toolset("s"));
|
||||
mcp.validate(ApiVersion::k20230601);
|
||||
ASSERT_TRUE(mcp.effective_betas().contains(Beta::kMcpClient20251120));
|
||||
ASSERT_EQ(mcp.to_json(false, ApiVersion::k20230601).find("mcp_servers")->as_array()[0].find("tool_configuration")->find("enabled")->as_bool(), true);
|
||||
}
|
||||
|
||||
TEST(anthropic_model, system_messages_and_mid_conversation_betas) {
|
||||
MessageParam s = MessageParam::system("Be formal from now on.");
|
||||
s.clear_at = "next_user_message";
|
||||
s.system_effort = "low";
|
||||
BetaSet b = s.required_betas();
|
||||
ASSERT_TRUE(b.contains(Beta::kMidConversationSystemClearAt20260821));
|
||||
ASSERT_TRUE(b.contains(Beta::kMidConversationOutputConfig20260701));
|
||||
ASSERT_EQ(s.to_json().find("clear_at")->as_string(), "next_user_message");
|
||||
MessageParam u = MessageParam::user("x");
|
||||
u.clear_at = "never";
|
||||
ASSERT_TRUE(throws_invalid([&] { u.to_json(); }));
|
||||
MessageParam tc = MessageParam::system({ContentBlock::from_json(Json::parse(R"({"type":"tool_removal","tool":{"type":"tool_reference","name":"get_weather"}})"))});
|
||||
ASSERT_TRUE(tc.required_betas().contains(Beta::kInlineTools20260915));
|
||||
}
|
||||
@@ -0,0 +1,474 @@
|
||||
// Anthropic core on the wire: the requests the services build (method, path,
|
||||
// headers, body) and the parsing of documented fixtures (fixtures.h). The mock
|
||||
// never decides anything; it records.
|
||||
#include "fixtures.h"
|
||||
#include "rig.h"
|
||||
|
||||
using namespace anthropic_test;
|
||||
namespace fx = anthropic_fixtures;
|
||||
|
||||
namespace {
|
||||
Json body_of(const MockTransport::SeenRequest& s) { return Json::parse(s.body); }
|
||||
} // namespace
|
||||
|
||||
TEST(anthropic_wire, messages_create_headers_body_and_documented_response) {
|
||||
SessionOptions o;
|
||||
o.version = ApiVersion::k20261021;
|
||||
o.workspace_id = "wrkspc_011CZkZaBF1tNoB5wlCeusgy";
|
||||
Rig r("sk-ant-SECRET", o);
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kMessageResponse));
|
||||
MessageRequest req = hello();
|
||||
req.add_tool(Tool::advisor("claude-opus-5-5"));
|
||||
req.betas.add(Beta::kContext1m20250807);
|
||||
req.user_profile_id = "uprof_1";
|
||||
MessageResult res = r.api->messages->create(req);
|
||||
auto s = r.last();
|
||||
ASSERT_EQ(s.method, "POST");
|
||||
ASSERT_EQ(s.headers.get_or("x-api-key", ""), "sk-ant-SECRET");
|
||||
ASSERT_EQ(s.headers.get_or("anthropic-version", ""), "2026-10-21");
|
||||
ASSERT_EQ(s.headers.get_or("anthropic-beta", ""), "context-1m-2025-08-07,advisor-tool-2026-03-01");
|
||||
ASSERT_EQ(s.headers.get_or("anthropic-workspace-id", ""), "wrkspc_011CZkZaBF1tNoB5wlCeusgy");
|
||||
ASSERT_EQ(s.headers.get_or("anthropic-user-profile-id", ""), "uprof_1");
|
||||
ASSERT_EQ(s.headers.get_or("Authorization", ""), "");
|
||||
ASSERT_EQ(s.target.find("SECRET"), std::string::npos);
|
||||
Json b = body_of(s);
|
||||
ASSERT_EQ(b.find("model")->as_string(), "claude-opus-5-5");
|
||||
ASSERT_EQ(b.find("max_tokens")->as_int(), 256);
|
||||
ASSERT_TRUE(b.find("stream") == nullptr);
|
||||
// documented response
|
||||
ASSERT_EQ(res.message.id, "msg_013Zva2CMHLNnXjNJJKqJ2EF");
|
||||
ASSERT_EQ(res.message.text(), "Hi! My name is Claude.");
|
||||
ASSERT_TRUE(res.message.stop_reason == StopReason::kEndTurn);
|
||||
ASSERT_EQ(res.message.usage.input_tokens, 2095);
|
||||
ASSERT_EQ(res.message.usage.output_tokens, 503);
|
||||
ASSERT_EQ(res.message.usage.cache_read_input_tokens, 2051);
|
||||
ASSERT_EQ(res.message.usage.inference_geo, "global");
|
||||
ASSERT_EQ(res.message.container.find("id")->as_string(), "container_011CpZohnwH4vuy7gazohgSP");
|
||||
ASSERT_EQ(res.message.stop_details.find("category")->as_string(), "cyber");
|
||||
auto cites = res.message.content[0].citations();
|
||||
ASSERT_EQ(cites.size(), 1u);
|
||||
ASSERT_EQ(cites[0].type, "char_location");
|
||||
ASSERT_EQ(cites[0].document_title, "My Document");
|
||||
ASSERT_EQ(res.betas.size(), 2u);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, local_validation_happens_before_traffic_and_credential_check) {
|
||||
Rig r("");
|
||||
MessageRequest bad_req = hello();
|
||||
bad_req.model.clear();
|
||||
try {
|
||||
r.api->messages->create(bad_req);
|
||||
FAIL("expected invalid");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_TRUE(e.kind() == ErrorKind::kInvalidArgument);
|
||||
}
|
||||
try {
|
||||
r.api->messages->create(hello());
|
||||
FAIL("expected not configured");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_TRUE(e.kind() == ErrorKind::kNotConfigured);
|
||||
ASSERT_EQ(e.http_status(), 503);
|
||||
}
|
||||
ASSERT_EQ(r.mock->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, errors_carry_kind_request_id_and_rate_limit_headers) {
|
||||
Rig r;
|
||||
HeaderMap h;
|
||||
h.set("Content-Type", "application/json");
|
||||
h.set("request-id", "req_011CSHoEeqs5C35K2UUqR7Fy");
|
||||
h.set("retry-after", "30");
|
||||
h.set("anthropic-ratelimit-requests-remaining", "0");
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", ClientResponse(429, h, fx::kErrorBody));
|
||||
try {
|
||||
r.api->messages->create(hello());
|
||||
FAIL("expected AnthropicError");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_EQ(e.http_status(), 429);
|
||||
ASSERT_EQ(e.type(), "not_found_error"); // the fixture body says so; kind follows the body type
|
||||
ASSERT_TRUE(e.kind() == ErrorKind::kNotFound);
|
||||
ASSERT_EQ(e.request_id(), "req_011CSHoEeqs5C35K2UUqR7Fy");
|
||||
ASSERT_EQ(*e.rate_limits().retry_after_seconds, 30.0);
|
||||
ASSERT_EQ(*e.rate_limits().requests.remaining, 0);
|
||||
ASSERT_TRUE(e.retryable()); // 429
|
||||
}
|
||||
Rig n;
|
||||
n.mock->expect_response(Method::kGet, "/v1/messages/batches/msgbatch_x", reply(fx::kErrorBody, 404));
|
||||
try {
|
||||
n.api->batches->retrieve("msgbatch_x");
|
||||
FAIL("expected AnthropicError");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_TRUE(e.kind() == ErrorKind::kNotFound);
|
||||
ASSERT_FALSE(e.retryable());
|
||||
}
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, stream_basic_decodes_every_event) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamBasic, 200, "text/event-stream"));
|
||||
std::vector<std::string> kinds;
|
||||
std::string text;
|
||||
StreamResult res = r.api->messages->stream(hello(), [&](const StreamEvent& e) {
|
||||
kinds.push_back(event_kind_name(e.kind));
|
||||
if (e.delta_kind == DeltaKind::kText) text += e.text;
|
||||
return true;
|
||||
});
|
||||
ASSERT_TRUE(res.complete);
|
||||
ASSERT_EQ(text, "Hello!");
|
||||
ASSERT_EQ(res.message.text(), "Hello!");
|
||||
ASSERT_TRUE(res.message.stop_reason == StopReason::kEndTurn);
|
||||
ASSERT_EQ(res.message.usage.output_tokens, 15); // cumulative message_delta replaces
|
||||
ASSERT_EQ(res.message.usage.input_tokens, 25);
|
||||
ASSERT_EQ(kinds.front(), "message_start");
|
||||
ASSERT_EQ(kinds.back(), "message_stop");
|
||||
ASSERT_EQ(std::count(kinds.begin(), kinds.end(), "ping"), 1);
|
||||
ASSERT_TRUE(body_of(r.last()).find("stream")->as_bool());
|
||||
ASSERT_EQ(r.last().headers.get_or("Accept", ""), "text/event-stream");
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, stream_tool_use_accumulates_input_json) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamToolUse, 200, "text/event-stream"));
|
||||
StreamResult res = r.api->messages->stream(hello());
|
||||
auto uses = res.message.tool_uses();
|
||||
ASSERT_EQ(uses.size(), 1u);
|
||||
ASSERT_TRUE(uses[0].input().has("location"));
|
||||
ASSERT_TRUE(res.message.stop_reason == StopReason::kToolUse);
|
||||
ASSERT_EQ(res.message.content.size(), 2u);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, stream_thinking_keeps_text_and_signature_for_replay) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamThinking, 200, "text/event-stream"));
|
||||
StreamResult res = r.api->messages->stream(hello());
|
||||
ASSERT_EQ(res.message.content.size(), 2u);
|
||||
const Block& t = res.message.content[0];
|
||||
ASSERT_TRUE(t.kind == BlockKind::kThinking);
|
||||
ASSERT_TRUE(t.thinking().find("GCD(1071, 462) = 21") != std::string::npos);
|
||||
ASSERT_EQ(t.signature().substr(0, 12), "EqQBCgIYAhIM");
|
||||
// The assistant turn goes back exactly as received.
|
||||
MessageParam p = res.message.as_param();
|
||||
ASSERT_EQ(p.blocks[0].json().find("signature")->as_string(), t.signature());
|
||||
MessageRequest next = hello();
|
||||
next.add(p);
|
||||
next.add(MessageParam::user("and 3?"));
|
||||
next.validate(ApiVersion::k20230601);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, stream_web_search_transcript_decodes_server_tool_events) {
|
||||
// The vendor abridged this transcript (a literal "..." line, ",...]" inside an
|
||||
// array, skipped events), so it cannot be accumulated. Every complete event is
|
||||
// still decoded; the abridged one is repaired by removing the ellipsis only.
|
||||
Rig r;
|
||||
std::string transcript = fx::kStreamWebSearch;
|
||||
for (std::size_t p; (p = transcript.find(",...]")) != std::string::npos;) transcript.replace(p, 5, "]");
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(transcript, 200, "text/event-stream"));
|
||||
std::vector<StreamEvent> events;
|
||||
try {
|
||||
r.api->messages->stream(hello(), [&](const StreamEvent& e) {
|
||||
events.push_back(e);
|
||||
return true;
|
||||
});
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "BAD_RESPONSE"); // the abridged transcript skips a content_block_start
|
||||
}
|
||||
bool server_tool = false, search_result = false;
|
||||
long searches = 0;
|
||||
for (const StreamEvent& e : events) {
|
||||
if (e.kind == EventKind::kContentBlockStart) {
|
||||
Block b;
|
||||
b.raw = *e.data.find("content_block");
|
||||
b.type = str_at(b.raw, "type");
|
||||
b.kind = block_kind_of(b.type);
|
||||
server_tool = server_tool || (b.kind == BlockKind::kServerToolUse && b.name() == "web_search");
|
||||
search_result = search_result || b.kind == BlockKind::kWebSearchToolResult;
|
||||
}
|
||||
if (e.kind == EventKind::kMessageDelta)
|
||||
searches = Usage::parse(*e.data.find("usage")).web_search_requests;
|
||||
}
|
||||
ASSERT_TRUE(server_tool);
|
||||
ASSERT_TRUE(search_result);
|
||||
ASSERT_TRUE(searches >= 0);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, stream_error_event_and_truncated_stream_are_loud) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamError, 200, "text/event-stream"));
|
||||
try {
|
||||
r.api->messages->stream(hello());
|
||||
FAIL("expected error event");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_TRUE(e.kind() == ErrorKind::kOverloaded);
|
||||
ASSERT_EQ(e.http_status(), 529);
|
||||
}
|
||||
Rig t;
|
||||
std::string cut = fx::kStreamBasic;
|
||||
cut.erase(cut.find("event: message_stop"));
|
||||
t.mock->expect_response(Method::kPost, "/v1/messages", reply(cut, 200, "text/event-stream"));
|
||||
try {
|
||||
t.api->messages->stream(hello());
|
||||
FAIL("expected UNEXPECTED_EOF");
|
||||
} catch (const AnthropicError& e) {
|
||||
ASSERT_EQ(e.type(), "UNEXPECTED_EOF");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, accumulator_rejects_disorder_and_stops_early_on_request) {
|
||||
StreamAccumulator a;
|
||||
auto ev = [](const char* name, const char* data) {
|
||||
molo::llm::SseEvent e;
|
||||
e.event = name;
|
||||
e.data = Json::parse(data);
|
||||
return StreamEvent::from_sse(e);
|
||||
};
|
||||
try {
|
||||
a.accept(ev("content_block_start", R"({"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}})"));
|
||||
FAIL("start before message_start");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "BAD_RESPONSE");
|
||||
}
|
||||
try {
|
||||
ev("message_stop", R"({"type":"content_block_stop"})");
|
||||
FAIL("name mismatch");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "BAD_RESPONSE");
|
||||
}
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages", reply(fx::kStreamBasic, 200, "text/event-stream"));
|
||||
int seen = 0;
|
||||
StreamResult res = r.api->messages->stream(hello(), [&](const StreamEvent&) { return ++seen < 4; });
|
||||
ASSERT_FALSE(res.complete);
|
||||
ASSERT_EQ(seen, 4);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, count_tokens_and_unknown_delta_kinds) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages/count_tokens", reply(fx::kCountTokensResponse));
|
||||
TokenCount t = r.api->messages->count_tokens(hello());
|
||||
ASSERT_EQ(t.input_tokens, 2095);
|
||||
ASSERT_TRUE(body_of(r.last()).find("max_tokens") == nullptr);
|
||||
ASSERT_TRUE(delta_kind_of("future_delta") == DeltaKind::kUnknown);
|
||||
ASSERT_EQ(std::string(delta_kind_type(DeltaKind::kSignature)), "signature_delta");
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, batches_build_union_betas_and_parse_documented_batch) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages/batches", reply(fx::kBatchResponse));
|
||||
BatchRequest a{"req-1", hello()};
|
||||
BatchRequest b{"req-2", hello()};
|
||||
b.params.add_tool(Tool::advisor("claude-opus-5-5"));
|
||||
Batch batch = r.api->batches->create({a, b}, "uprof_9");
|
||||
auto s = r.last();
|
||||
ASSERT_EQ(s.headers.get_or("anthropic-beta", ""), "advisor-tool-2026-03-01");
|
||||
ASSERT_EQ(s.headers.get_or("anthropic-user-profile-id", ""), "uprof_9");
|
||||
Json body = body_of(s);
|
||||
ASSERT_EQ(body.find("requests")->as_array().size(), 2u);
|
||||
ASSERT_EQ(body.find("requests")->as_array()[0].find("custom_id")->as_string(), "req-1");
|
||||
ASSERT_TRUE(body.find("requests")->as_array()[0].find("params")->find("stream") == nullptr);
|
||||
ASSERT_EQ(batch.id, "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF");
|
||||
ASSERT_EQ(batch.processing_status, "in_progress");
|
||||
ASSERT_EQ(batch.counts.succeeded, 50);
|
||||
ASSERT_EQ(batch.counts.total(), 200);
|
||||
ASSERT_FALSE(batch.ended());
|
||||
ASSERT_TRUE(batch.results_url.find("/results") != std::string::npos);
|
||||
// rules
|
||||
BatchRequest dup{"req-1", hello()};
|
||||
try {
|
||||
r.api->batches->create({a, dup});
|
||||
FAIL("duplicate custom_id");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
BatchRequest badid{"has space", hello()};
|
||||
try {
|
||||
r.api->batches->create({badid});
|
||||
FAIL("custom_id pattern");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
ASSERT_EQ(r.mock->send_count(), 1u);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, batch_results_jsonl_kinds_and_bad_lines_counted) {
|
||||
Rig r;
|
||||
std::string msg = fx::kMessageResponse;
|
||||
std::string compact = Json::parse(msg).dump();
|
||||
std::string jsonl = "{\"custom_id\":\"a\",\"result\":{\"type\":\"succeeded\",\"message\":" + compact + "}}\n" +
|
||||
"{\"custom_id\":\"b\",\"result\":{\"type\":\"errored\",\"error\":{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"x\"}}}}\n" +
|
||||
"{\"custom_id\":\"c\",\"result\":{\"type\":\"canceled\"}}\n{\"custom_id\":\"d\",\"result\":{\"type\":\"expired\"}}\nnot json\n\n";
|
||||
r.mock->expect_response(Method::kGet, "/v1/messages/batches/msgbatch_1/results", reply(jsonl, 200, "application/x-jsonl"));
|
||||
BatchResults res = r.api->batches->results("msgbatch_1");
|
||||
ASSERT_EQ(res.items.size(), 4u);
|
||||
ASSERT_EQ(res.skipped_lines, 1u);
|
||||
ASSERT_EQ(res.items[0].type, "succeeded");
|
||||
ASSERT_EQ(res.items[0].message->text(), "Hi! My name is Claude.");
|
||||
ASSERT_EQ(res.items[1].type, "errored");
|
||||
ASSERT_EQ(res.items[1].error.find("error")->find("type")->as_string(), "invalid_request_error");
|
||||
ASSERT_EQ(res.items[2].type, "canceled");
|
||||
ASSERT_EQ(res.items[3].type, "expired");
|
||||
ASSERT_FALSE(res.truncated);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, batch_lifecycle_calls_use_the_table) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/messages/batches/msgbatch_1/cancel", reply(fx::kBatchResponse));
|
||||
r.mock->expect_response(Method::kDelete, "/v1/messages/batches/msgbatch_1", reply(R"({"id":"msgbatch_1","type":"message_batch_deleted"})"));
|
||||
r.mock->expect_response(Method::kGet, "/v1/messages/batches", reply(R"({"data":[],"has_more":false,"first_id":null,"last_id":null})"));
|
||||
r.api->batches->cancel("msgbatch_1");
|
||||
ASSERT_EQ(r.api->batches->destroy("msgbatch_1").find("type")->as_string(), "message_batch_deleted");
|
||||
Page p = r.api->batches->list(5, "msgbatch_0");
|
||||
ASSERT_FALSE(p.has_more);
|
||||
ASSERT_TRUE(r.last().target.find("limit=5") != std::string::npos);
|
||||
ASSERT_TRUE(r.last().target.find("after_id=msgbatch_0") != std::string::npos);
|
||||
try {
|
||||
r.api->batches->list(5000);
|
||||
FAIL("limit cap");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
try {
|
||||
r.api->batches->cancel("../x");
|
||||
FAIL("id check");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, models_documented_response_and_capabilities) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kGet, "/v1/models/claude-opus-5-5", reply(fx::kModelResponse));
|
||||
ModelInfo m = r.api->models->retrieve("claude-opus-5-5");
|
||||
ASSERT_EQ(m.id, "claude-opus-5-5");
|
||||
ASSERT_EQ(m.display_name, "Claude Opus 5.5");
|
||||
ASSERT_EQ(m.lifecycle, "active");
|
||||
ASSERT_EQ(m.line, "haiku"); // the documented example value, verbatim
|
||||
ASSERT_TRUE(m.supports("batch"));
|
||||
ASSERT_TRUE(m.supports("thinking.types.adaptive"));
|
||||
ASSERT_TRUE(m.supports("effort.xhigh"));
|
||||
ASSERT_TRUE(m.supports("server_tools.web_search"));
|
||||
ASSERT_FALSE(m.supports("thinking.types.nonexistent"));
|
||||
r.mock->expect_response(Method::kGet, "/v1/models", reply(R"({"data":[],"has_more":false})"));
|
||||
r.api->models->list(10, "", "", {"active", "deprecated"});
|
||||
ASSERT_TRUE(r.last().target.find("lifecycle=active&lifecycle=deprecated") != std::string::npos);
|
||||
try {
|
||||
r.api->models->list(0, "", "", {"gone"});
|
||||
FAIL("lifecycle values");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, files_upload_list_download_delete) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/files", reply(fx::kFileResponse));
|
||||
FileMeta f = r.api->files->upload("document.pdf", "%PDF-1.4", "application/pdf", 7200);
|
||||
ASSERT_EQ(f.id, "file_011CNha8iCJcU1wXNR6q4V8w");
|
||||
ASSERT_EQ(f.size_bytes, 102400);
|
||||
auto s = r.last();
|
||||
ASSERT_TRUE(s.headers.get_or("Content-Type", "").find("multipart/form-data") == 0);
|
||||
ASSERT_TRUE(s.body.find("name=\"file\"; filename=\"document.pdf\"") != std::string::npos);
|
||||
ASSERT_TRUE(s.body.find("name=\"expires_in_seconds\"") != std::string::npos);
|
||||
auto bad_upload = [&](const std::string& n, const std::string& d, long ex) {
|
||||
try {
|
||||
r.api->files->upload(n, d, "text/plain", ex);
|
||||
return false;
|
||||
} catch (const molo::llm::ApiError&) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
ASSERT_TRUE(bad_upload("a/b.txt", "x", 0));
|
||||
ASSERT_TRUE(bad_upload("a.txt", "", 0));
|
||||
ASSERT_TRUE(bad_upload("a.txt", "x", 10));
|
||||
ASSERT_TRUE(bad_upload("a.txt", "x", 8000000));
|
||||
r.mock->expect_response(Method::kGet, "/v1/files/file_1/content", reply("RAW\x01\x02", 200, "application/pdf"));
|
||||
FileContent c = r.api->files->download("file_1");
|
||||
ASSERT_EQ(c.bytes, std::string("RAW\x01\x02"));
|
||||
r.mock->expect_response(Method::kDelete, "/v1/files/file_1", reply(R"({"id":"file_1","type":"file_deleted"})"));
|
||||
ASSERT_EQ(r.api->files->destroy("file_1").find("type")->as_string(), "file_deleted");
|
||||
r.mock->expect_response(Method::kGet, "/v1/files", reply(R"({"data":[],"next_page":"page_x"})"));
|
||||
Page p = r.api->files->list(0, "", {"file_1", "file_2"});
|
||||
ASSERT_TRUE(p.has_more);
|
||||
ASSERT_EQ(p.next_page, "page_x");
|
||||
ASSERT_TRUE(r.last().target.find("ids=file_1&ids=file_2") != std::string::npos);
|
||||
try {
|
||||
r.api->files->list(5, "", {"file_1"});
|
||||
FAIL("ids exclusive");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, files_and_skills_can_send_legacy_beta_headers) {
|
||||
Rig r;
|
||||
r.api->files->with_betas(BetaSet{Beta::kFilesApi20250414});
|
||||
r.mock->expect_response(Method::kGet, "/v1/files/file_1", reply(fx::kFileResponse));
|
||||
r.api->files->metadata("file_1");
|
||||
ASSERT_EQ(r.last().headers.get_or("anthropic-beta", ""), "files-api-2025-04-14");
|
||||
r.api->skills->with_betas(BetaSet{Beta::kSkills20251002});
|
||||
r.mock->expect_response(Method::kGet, "/v1/skills/skill_1/versions/1759178010641129", reply(fx::kSkillVersionResponse));
|
||||
r.api->skills->retrieve_version("skill_1", "1759178010641129");
|
||||
ASSERT_EQ(r.last().headers.get_or("anthropic-beta", ""), "skills-2025-10-02");
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, skills_upload_rules_and_multipart_field_name) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/skills", reply(R"({"id":"skill_1","type":"skill"})"));
|
||||
r.api->skills->create({{"my-skill/SKILL.md", "---\nname: my-skill\n---", "text/markdown"}, {"my-skill/run.py", "print(1)", "text/x-python"}}, "My skill");
|
||||
auto s = r.last();
|
||||
ASSERT_TRUE(s.body.find("name=\"files[]\"; filename=\"my-skill/SKILL.md\"") != std::string::npos);
|
||||
ASSERT_TRUE(s.body.find("name=\"display_name\"") != std::string::npos);
|
||||
auto rejects = [&](std::vector<SkillFile> files) {
|
||||
try {
|
||||
validate_skill_files(files);
|
||||
return false;
|
||||
} catch (const molo::llm::ApiError&) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
ASSERT_TRUE(rejects({}));
|
||||
ASSERT_TRUE(rejects({{"a/readme.md", "x", "text/plain"}})); // no SKILL.md
|
||||
ASSERT_TRUE(rejects({{"a/SKILL.md", "x", ""}, {"b/x.py", "x", ""}})); // two top dirs
|
||||
ASSERT_TRUE(rejects({{"../SKILL.md", "x", ""}}));
|
||||
ASSERT_TRUE(rejects({{"/abs/SKILL.md", "x", ""}}));
|
||||
ASSERT_FALSE(rejects({{"SKILL.md", "x", ""}})); // GA: SKILL.md may sit at the root
|
||||
r.mock->expect_response(Method::kDelete, "/v1/skills/skill_1", reply(R"({"id":"skill_1","type":"skill_deleted"})"));
|
||||
ASSERT_EQ(r.api->skills->destroy("skill_1").find("type")->as_string(), "skill_deleted");
|
||||
r.mock->expect_response(Method::kGet, "/v1/skills/skill_1/versions/latest/content", reply("PK\x03\x04", 200, "application/zip"));
|
||||
ASSERT_EQ(r.api->skills->download_version("skill_1", "latest").substr(0, 2), "PK");
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, user_profiles_and_completions) {
|
||||
Rig r;
|
||||
r.mock->expect_response(Method::kPost, "/v1/user_profiles", reply(R"({"id":"uprof_1","type":"user_profile"})"));
|
||||
r.api->user_profiles->create(Json::parse(R"({"name":"Ada","access_type":"application","metadata":{"k":"v"}})"));
|
||||
ASSERT_EQ(body_of(r.last()).find("name")->as_string(), "Ada");
|
||||
try {
|
||||
r.api->user_profiles->create(Json::parse(R"({"bogus":1})"));
|
||||
FAIL("unknown field");
|
||||
} catch (const molo::llm::ApiError& e) {
|
||||
ASSERT_EQ(e.type(), "INVALID_ARGUMENT");
|
||||
}
|
||||
r.mock->expect_response(Method::kPost, "/v1/user_profiles/uprof_1/enrollment_url", reply(R"({"type":"enrollment_url","url":"https://x","expires_at":"2026-10-24T00:00:00Z"})"));
|
||||
ASSERT_EQ(r.api->user_profiles->create_enrollment_url("uprof_1").find("url")->as_string(), "https://x");
|
||||
r.mock->expect_response(Method::kPost, "/v1/complete", reply(R"({"type":"completion","id":"compl_1","completion":" Hi","model":"claude-2.1","stop_reason":"stop_sequence"})"));
|
||||
CompletionRequest cr;
|
||||
cr.model = "claude-2.1";
|
||||
cr.prompt = "\n\nHuman: Hello, world!\n\nAssistant:";
|
||||
cr.max_tokens_to_sample = 256;
|
||||
Completion c = r.api->completions->create(cr);
|
||||
ASSERT_EQ(c.completion, " Hi");
|
||||
ASSERT_EQ(body_of(r.last()).find("max_tokens_to_sample")->as_int(), 256);
|
||||
}
|
||||
|
||||
TEST(anthropic_wire, session_defaults_betas_and_version_override) {
|
||||
SessionOptions o;
|
||||
o.betas.add(Beta::kContext1m20250807);
|
||||
Rig r("k", o);
|
||||
r.mock->expect_response(Method::kGet, "/v1/models", reply(R"({"data":[]})"));
|
||||
r.api->models->list();
|
||||
ASSERT_EQ(r.last().headers.get_or("anthropic-beta", ""), "context-1m-2025-08-07");
|
||||
ASSERT_EQ(r.last().headers.get_or("anthropic-version", ""), "2023-06-01");
|
||||
auto h = r.session->headers({}, "", "", ApiVersion::k20261021);
|
||||
ASSERT_EQ(h["anthropic-version"], "2026-10-21");
|
||||
ASSERT_EQ(r.session->last_response().request_id, "req_test");
|
||||
}
|
||||
Reference in New Issue
Block a user