Python
//! OpenAI-compatible Chat Completions for local and hosted models.
//! Only a fully terminated, validated completion can authorize tool execution.
use crate::provider::{Completion, Error, Failure, StreamDecoder, Usage};
use serde_json::{json, Value};
use std::collections::{BTreeMap, BTreeSet};
fn invalid() -> Error {
Error::new(Failure::InvalidResponse).with_code("invalid_chat_completion")
}
fn config() -> Error {
Error::new(Failure::Configuration).with_code("invalid_chat_request_history")
}
const GOOGLE_PRIVATE: &str = "google-chat-completions";
const MAX_SIGNATURE_BYTES: usize = 256_000;
/// Google signatures are opaque replay state, never user-visible reasoning.
/// Scope them to the authenticated connection, transport, endpoint and model.
pub fn replay_binding(endpoint: &str, model: &str, connection_identity: Option<&str>) -> String {
crate::bundle::digest(
json!(["chat-completions", endpoint, model, connection_identity])
.to_string()
.as_bytes(),
)
}
fn google_signature(value: &Value) -> Result<Option<String>, Error> {
let Some(value) = value
.get("extra_content")
.and_then(|v| v.get("google"))
.and_then(|v| v.get("thought_signature"))
else {
return Ok(None);
};
let signature = value.as_str().ok_or_else(invalid)?;
if signature.is_empty() || signature.len() > MAX_SIGNATURE_BYTES {
return Err(invalid());
}
Ok(Some(signature.to_owned()))
}
fn private_signature(binding: &str, target: &str, id: &str, signature: String) -> Value {
json!({"type":"reasoning","provider":GOOGLE_PRIVATE,"binding":binding,
"block":{"type":"thought_signature","target":target,"id":id,"signature":signature}})
}
pub fn message_signature(item: &Value) -> bool {
item["type"] == "reasoning"
&& item["provider"] == GOOGLE_PRIVATE
&& item["block"]["target"] == "message"
}
pub(crate) fn signed_tool_id(item: &Value) -> Option<&str> {
if item["type"] == "reasoning"
&& item["provider"] == GOOGLE_PRIVATE
&& item["block"]["target"] == "tool_call"
{
item["block"]["id"].as_str()
} else {
None
}
}
fn content(value: &Value) -> Result<Value, Error> {
if value.is_string() {
return Ok(value.clone());
}
let blocks = value.as_array().ok_or_else(config)?.iter().map(|p| {
match p["type"].as_str() {
Some("text" | "input_text" | "output_text") => Ok(json!({"type":"text","text":p["text"].as_str().ok_or_else(config)?})),
Some("input_file") => Ok(json!({"type":"file","file":{"filename":p["filename"],"file_data":p["file_data"]}})),
Some("input_image") => Ok(json!({"type":"image_url","image_url":{"url":p["image_url"].as_str().ok_or_else(config)?}})),
_ => Err(config()),
}
}).collect::<Result<Vec<_>,_>>()?;
Ok(json!(blocks))
}
pub fn body(
model: &str,
instructions: &str,
history: &[Value],
tools: &[Value],
max_tokens: usize,
format: Option<&Value>,
) -> Result<Value, Error> {
body_with_binding(
model,
instructions,
history,
tools,
max_tokens,
format,
None,
)
}
#[allow(clippy::too_many_arguments)]
pub fn body_with_binding(
model: &str,
instructions: &str,
history: &[Value],
tools: &[Value],
max_tokens: usize,
format: Option<&Value>,
binding: Option<&str>,
) -> Result<Value, Error> {
let mut messages = vec![json!({"role":"system","content":instructions})];
let mut pending = BTreeSet::new();
let mut seen = BTreeSet::new();
let mut signatures = BTreeMap::new();
for item in history.iter().filter(|item| item["type"] == "reasoning") {
let block = &item["block"];
let target = block["target"].as_str().ok_or_else(config)?;
let id = block["id"]
.as_str()
.filter(|id| !id.is_empty())
.ok_or_else(config)?;
let signature = block["signature"]
.as_str()
.filter(|s| !s.is_empty() && s.len() <= MAX_SIGNATURE_BYTES)
.ok_or_else(config)?;
if item["provider"] != GOOGLE_PRIVATE
|| binding.is_none()
|| item["binding"].as_str() != binding
|| block["type"] != "thought_signature"
|| !["tool_call", "message"].contains(&target)
|| signatures.insert((target, id), signature).is_some()
{
return Err(config());
}
}
for item in history {
if item["type"] == "reasoning" {
continue;
}
// Encrypted/signed reasoning must never cross to another API.
if item.get("provider").is_some() {
return Err(config());
}
match item["type"].as_str() {
Some("function_call") => {
let id = item["call_id"].as_str().ok_or_else(config)?;
if !seen.insert(id) {
return Err(config());
}
pending.insert(id);
let arguments = item["arguments"].as_str().ok_or_else(config)?;
if !serde_json::from_str::<Value>(arguments)
.map_err(|_| config())?
.is_object()
{
return Err(config());
}
let mut call = json!({"id":id,"type":"function","function":{"name":item["name"].as_str().ok_or_else(config)?,"arguments":arguments}});
if let Some(signature) = signatures.remove(&("tool_call", id)) {
call["extra_content"] = json!({"google":{"thought_signature":signature}});
}
if messages.last().is_some_and(|m| m["role"] == "assistant") {
let last = messages.last_mut().unwrap();
if last.get("tool_calls").is_none() {
last["tool_calls"] = json!([]);
}
last["tool_calls"].as_array_mut().unwrap().push(call);
} else {
messages.push(json!({"role":"assistant","content":null,"tool_calls":[call]}));
}
}
Some("function_call_output") => {
let id = item["call_id"].as_str().ok_or_else(config)?;
if !pending.remove(id) {
return Err(config());
}
messages.push(
json!({"role":"tool","tool_call_id":id,"content":content(&item["output"])?}),
);
}
Some("message") | None => {
if !pending.is_empty() {
return Err(config());
}
let role = item["role"].as_str().ok_or_else(config)?;
if !["assistant", "user"].contains(&role) {
return Err(config());
}
let mut message = json!({"role":role,"content":content(&item["content"])?});
if let Some(id) = item["id"].as_str() {
if let Some(signature) = signatures.remove(&("message", id)) {
if role != "assistant" {
return Err(config());
}
message["extra_content"] =
json!({"google":{"thought_signature":signature}});
}
}
messages.push(message);
}
_ => return Err(config()),
}
}
if !pending.is_empty() || !signatures.is_empty() {
return Err(config());
}
let definitions = tools.iter().map(|tool| {
if tool["type"] != "function" || !tool["parameters"].is_object() { return Err(config()); }
Ok(json!({"type":"function","function":{"name":tool["name"].as_str().ok_or_else(config)?,"description":tool["description"].as_str().unwrap_or(""),"parameters":tool["parameters"]}}))
}).collect::<Result<Vec<_>,_>>()?;
// The compatible/local API (including Ollama) accepts max_tokens. Models
// requiring OpenAI's newer reasoning contract should use Responses instead.
let mut result = json!({"model":model,"messages":messages,"stream":true,"stream_options":{"include_usage":true},"max_tokens":max_tokens});
if !definitions.is_empty() {
result["tools"] = json!(definitions);
result["parallel_tool_calls"] = json!(false);
}
if let Some(format) = format {
if format["type"] != "json_schema" || !format["schema"].is_object() {
return Err(config());
}
result["response_format"] = json!({"type":"json_schema","json_schema":{"name":format["name"],"schema":format["schema"],"strict":format["strict"]}});
}
Ok(result)
}
#[derive(Default)]
struct Call {
id: String,
name: String,
arguments: String,
signature: Option<String>,
/// Unindexed Gemini calls must be complete, self-contained objects.
complete: bool,
}
#[derive(Default)]
pub struct Decoder {
id: Option<String>,
text: String,
calls: BTreeMap<u64, Call>,
reason: Option<String>,
done: bool,
accounting_tail: bool,
usage: Option<Usage>,
bytes: usize,
reasoning: Option<crate::provider::ReasoningDelta>,
binding: Option<String>,
google_compat: bool,
message_signature: Option<String>,
failed: bool,
}
impl Decoder {
pub fn with_binding(binding: String, google_compat: bool) -> Self {
Self {
binding: Some(binding),
google_compat,
..Self::default()
}
}
fn accept(&mut self, event: &Value) -> Result<Option<String>, Error> {
if self.done || self.accounting_tail || event.get("error").is_some() {
return Err(invalid());
}
if let Some(id) = event["id"].as_str() {
if self.id.as_ref().is_some_and(|old| old != id) {
return Err(invalid());
}
self.id = Some(id.into());
}
self.bytes += event.to_string().len();
if self.bytes > 8 * 1024 * 1024 {
return Err(invalid());
}
let usage = event
.get("usage")
.filter(|u| !u.is_null())
.map(|usage| {
Ok::<_, Error>(Usage {
input_tokens: usage["prompt_tokens"].as_u64().ok_or_else(invalid)?,
output_tokens: usage["completion_tokens"].as_u64().ok_or_else(invalid)?,
cached_input_tokens: usage["prompt_tokens_details"]["cached_tokens"]
.as_u64()
.unwrap_or(0),
cache_read_input_tokens: usage["prompt_tokens_details"]["cached_tokens"]
.as_u64(),
cache_write_input_tokens: None,
reasoning_output_tokens: usage["completion_tokens_details"]["reasoning_tokens"]
.as_u64(),
})
})
.transpose()?;
let choices = event["choices"].as_array().ok_or_else(invalid)?;
if choices.is_empty() {
return if self.reason.is_some() && usage.is_some() {
self.usage = usage;
self.accounting_tail = true;
Ok(None)
} else {
Err(invalid())
};
}
if choices.len() != 1 || choices[0]["index"] != 0 {
return Err(invalid());
}
let choice = &choices[0];
let delta = &choice["delta"];
if let Some(reason) = &self.reason {
// OpenRouter's final usage chunk repeats the terminal reason with an
// empty delta, unlike OpenAI's choices:[] accounting chunk. It is not
// a second completion and cannot append text or tool arguments.
// https://openrouter.ai/docs/api_reference/streaming
if usage.is_none()
|| choice["finish_reason"].as_str() != Some(reason.as_str())
|| choice.get("error").is_some()
|| event["id"]
.as_str()
.is_none_or(|id| Some(id) != self.id.as_deref())
|| !delta.as_object().is_some_and(|fields| {
fields.iter().all(|(key, value)| match key.as_str() {
"role" => value.is_null() || value == "assistant",
"content" => value.is_null() || value == "",
"tool_calls" => {
value.is_null() || value.as_array().is_some_and(Vec::is_empty)
}
"refusal" => value.is_null(),
_ => false,
})
})
{
return Err(invalid());
}
self.usage = usage;
self.accounting_tail = true;
return Ok(None);
}
if usage.is_some() {
self.usage = usage;
}
if !delta.is_object()
|| delta.get("role").is_some_and(|r| r != "assistant")
|| delta.get("refusal").is_some_and(|r| !r.is_null())
{
return Err(Error::new(Failure::SafetyBlocked));
}
if let Some(signature) = google_signature(delta)? {
if self.binding.is_none() {
return Err(config());
}
if self
.message_signature
.as_ref()
.is_some_and(|old| old != &signature)
{
return Err(invalid());
}
self.message_signature = Some(signature);
self.google_compat = true;
}
let text = match delta.get("content").filter(|v| !v.is_null()) {
Some(value) => {
let s = value.as_str().ok_or_else(invalid)?;
self.text.push_str(s);
Some(s.to_owned())
}
None => None,
};
let reasoning_content = delta.get("reasoning_content").filter(|v| !v.is_null());
let reasoning = delta.get("reasoning").filter(|v| !v.is_null());
if reasoning_content
.zip(reasoning)
.is_some_and(|(a, b)| a != b)
{
return Err(invalid());
}
if let Some(text) = reasoning_content.or(reasoning) {
self.reasoning = Some(crate::provider::ReasoningDelta {
kind: crate::provider::ReasoningKind::Thinking,
text: text.as_str().ok_or_else(invalid)?.to_owned(),
block_index: 0,
});
}
if let Some(calls) = delta.get("tool_calls") {
for c in calls.as_array().ok_or_else(invalid)? {
let signature = google_signature(c)?;
if signature.is_some() {
if self.binding.is_none() {
return Err(config());
}
self.google_compat = true;
}
let unindexed = c.get("index").is_none();
let index = if unindexed && self.google_compat {
// Google's compatible endpoint may emit complete calls
// without indexes. Never guess how to join partial calls.
let id = c["id"]
.as_str()
.filter(|id| !id.is_empty())
.ok_or_else(invalid)?;
c["function"]["name"]
.as_str()
.filter(|name| !name.is_empty())
.ok_or_else(invalid)?;
let arguments = c["function"]["arguments"].as_str().ok_or_else(invalid)?;
if !serde_json::from_str::<Value>(arguments)
.map_err(|_| invalid())?
.is_object()
|| self.calls.values().any(|call| call.id == id)
{
return Err(invalid());
}
self.calls.keys().next_back().map_or(0, |index| index + 1)
} else {
c["index"]
.as_u64()
.ok_or_else(|| invalid().with_code("invalid_tool_call_index"))?
};
if index >= 64 || c.get("type").is_some_and(|v| v != "function") {
return Err(invalid());
}
let call = self.calls.entry(index).or_default();
if call.complete {
return Err(invalid());
}
if let Some(id) = c.get("id") {
let id = id
.as_str()
.filter(|id| !id.is_empty())
.ok_or_else(invalid)?;
if !call.id.is_empty() && (!self.google_compat || call.id != id) {
return Err(invalid());
}
call.id = id.into();
}
if let Some(name) = c["function"].get("name") {
let name = name.as_str().ok_or_else(invalid)?;
if !self.google_compat || call.name != name {
call.name.push_str(name);
}
}
if let Some(args) = c["function"].get("arguments") {
call.arguments.push_str(args.as_str().ok_or_else(invalid)?);
}
if let Some(signature) = signature {
if call.signature.as_ref().is_some_and(|old| old != &signature) {
return Err(invalid());
}
call.signature = Some(signature);
}
call.complete = unindexed;
}
}
if let Some(reason) = choice.get("finish_reason").filter(|v| !v.is_null()) {
match reason.as_str() {
Some("stop") if self.calls.is_empty() || self.google_compat => {}
Some("tool_calls") if !self.calls.is_empty() => {}
Some("length") => return Err(Error::new(Failure::Truncated)),
Some("content_filter") => return Err(Error::new(Failure::SafetyBlocked)),
_ => return Err(invalid()),
}
self.reason = Some(reason.as_str().unwrap().into());
}
Ok(text)
}
}
impl StreamDecoder for Decoder {
fn take_reasoning(&mut self) -> Option<crate::provider::ReasoningDelta> {
self.reasoning.take()
}
fn usage_report(&self) -> Option<crate::telemetry::TokenUsage> {
self.usage.as_ref().map(Usage::reported)
}
fn output_started(&self) -> bool {
!self.text.is_empty()
|| self
.calls
.values()
.any(|c| !c.name.is_empty() || !c.arguments.is_empty())
}
fn event(&mut self, event: &Value) -> Result<Option<String>, Error> {
if self.failed {
return Err(invalid());
}
let result = self.accept(event);
if result.is_err() {
self.failed = true;
}
result
}
fn done(&mut self) -> Result<(), Error> {
if self.failed || self.done || self.reason.is_none() {
return Err(invalid());
}
self.done = true;
Ok(())
}
fn finish(self) -> Result<Completion, Error> {
if self.failed {
return Err(invalid());
}
if !self.done || self.reason.is_none() {
return Err(Error::new(Failure::IncompleteStream));
}
let mut output = vec![];
if !self.text.is_empty() || self.message_signature.is_some() {
let mut message = json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":self.text}]});
if let Some(signature) = self.message_signature {
let id = crate::id("chat_message");
output.push(private_signature(
self.binding.as_deref().ok_or_else(config)?,
"message",
&id,
signature,
));
message["id"] = json!(id);
}
output.push(message);
}
for (index, call) in self.calls {
if call.id.is_empty() || call.name.is_empty() {
return Err(invalid());
}
if let Some(signature) = call.signature {
output.push(private_signature(
self.binding.as_deref().ok_or_else(config)?,
"tool_call",
&call.id,
signature,
));
}
output.push(json!({"type":"function_call","id":format!("chat_call_{index}"),"call_id":call.id,"name":call.name,"arguments":call.arguments}));
}
if output.is_empty() || crate::model::validate_output(&output).is_err() {
return Err(invalid());
}
Ok(Completion {
output,
usage: self.usage,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn signed_call(id: &str) -> Value {
json!({"id":id,"type":"function","function":{"name":"app__lookup","arguments":"{\"name\":\"example\"}"},"extra_content":{"google":{"thought_signature":"OPAQUE_SIGNATURE"}}})
}
#[test]
fn gemini_complete_unindexed_calls_preserve_signatures_and_parallel_order() {
let binding = replay_binding(
"https://example.test/openai/chat/completions",
"gemini-fixture",
Some("identity-1"),
);
let mut d = Decoder::with_binding(binding.clone(), false);
let second = json!({"id":"call-2","type":"function","function":{"name":"app__lookup","arguments":"{\"name\":\"other\"}"}});
assert_eq!(
d.event(&chunk(
json!({"role":"assistant","tool_calls":[signed_call("call-1"),second]}),
Value::Null
))
.unwrap(),
None
);
d.event(&chunk(json!({"role":"assistant"}), json!("stop")))
.unwrap();
d.done().unwrap();
let completion = d.finish().unwrap();
assert_eq!(completion.output[0]["type"], "reasoning");
assert_eq!(completion.output[1]["call_id"], "call-1");
assert_eq!(completion.output[2]["call_id"], "call-2");
let mut history = vec![json!({"role":"user","content":"Look up both"})];
history.extend(completion.output);
for id in ["call-1", "call-2"] {
history.push(json!({"type":"function_call_output","call_id":id,"output":"available"}));
}
let request = body_with_binding(
"gemini-fixture",
"Instructions",
&history,
&[],
100,
None,
Some(&binding),
)
.unwrap();
assert_eq!(
request["messages"][2]["tool_calls"][0]["extra_content"]["google"]["thought_signature"],
"OPAQUE_SIGNATURE"
);
assert_eq!(request["messages"][2]["tool_calls"][1]["id"], "call-2");
assert!(request["messages"][2]["tool_calls"][1]
.get("extra_content")
.is_none());
assert_eq!(request["messages"][3]["tool_call_id"], "call-1");
assert_eq!(request["messages"][4]["tool_call_id"], "call-2");
assert!(
!serde_json::to_string(&crate::model::public_items(&history))
.unwrap()
.contains("OPAQUE_SIGNATURE")
);
assert!(
crate::anthropic::body("claude", "Instructions", &history, &[], 100, None).is_err()
);
assert!(body("gemini-fixture", "Instructions", &history, &[], 100, None).is_err());
for changed in [
replay_binding(
"https://other.test/openai/chat/completions",
"gemini-fixture",
Some("identity-1"),
),
replay_binding(
"https://example.test/openai/chat/completions",
"other-model",
Some("identity-1"),
),
replay_binding(
"https://example.test/openai/chat/completions",
"gemini-fixture",
Some("identity-2"),
),
] {
assert!(body_with_binding(
"gemini-fixture",
"Instructions",
&history,
&[],
100,
None,
Some(&changed)
)
.is_err());
}
}
#[test]
fn gemini_indexed_fragments_and_terminal_text_signatures_roundtrip() {
let mut d = Decoder::with_binding("binding".into(), true);
d.event(&chunk(json!({"tool_calls":[{"index":0,"id":"call-1","type":"function","function":{"name":"app__lookup","arguments":"{\"name\":"}}]}), Value::Null)).unwrap();
d.event(&chunk(json!({"tool_calls":[{"index":0,"id":"call-1","function":{"arguments":"\"example\"}"},"extra_content":{"google":{"thought_signature":"OPAQUE_SIGNATURE"}}}]}), json!("stop"))).unwrap();
d.done().unwrap();
assert_eq!(
d.finish().unwrap().output[1]["arguments"],
"{\"name\":\"example\"}"
);
let mut text = Decoder::with_binding("binding".into(), true);
assert_eq!(
text.event(&chunk(json!({"content":"The answer"}), Value::Null))
.unwrap(),
Some("The answer".into())
);
assert_eq!(text.event(&chunk(json!({"content":"","extra_content":{"google":{"thought_signature":"TEXT_SIGNATURE"}}}), json!("stop"))).unwrap(), Some("".into()));
text.done().unwrap();
let mut history = vec![json!({"role":"user","content":"Question"})];
history.extend(text.finish().unwrap().output);
history.push(json!({"role":"user","content":"Follow up"}));
let replay = body_with_binding(
"fixture",
"Instructions",
&history,
&[],
100,
None,
Some("binding"),
)
.unwrap();
assert_eq!(replay["messages"][2]["content"][0]["text"], "The answer");
assert_eq!(
replay["messages"][2]["extra_content"]["google"]["thought_signature"],
"TEXT_SIGNATURE"
);
assert!(
!serde_json::to_string(&crate::model::public_items(&history))
.unwrap()
.contains("TEXT_SIGNATURE")
);
}
#[test]
fn gemini_metadata_does_not_authorize_ambiguous_or_incomplete_calls() {
let mut partial = signed_call("call-1");
partial["function"]["arguments"] = json!("{");
let mut no_id = signed_call("call-1");
no_id.as_object_mut().unwrap().remove("id");
let mut bad_signature = signed_call("call-1");
bad_signature["extra_content"]["google"]["thought_signature"] = json!(42);
for call in [partial, no_id, bad_signature] {
let mut d = Decoder::with_binding("binding".into(), true);
assert!(d
.event(&chunk(json!({"tool_calls":[call]}), json!("stop")))
.is_err());
assert!(d.done().is_err());
assert!(d.finish().is_err());
}
let mut duplicate = Decoder::with_binding("binding".into(), true);
assert!(duplicate
.event(&chunk(
json!({"tool_calls":[signed_call("same"),signed_call("same")]}),
json!("stop")
))
.is_err());
let mut incomplete = Decoder::with_binding("binding".into(), true);
incomplete
.event(&chunk(
json!({"tool_calls":[signed_call("call-1")]}),
json!("stop"),
))
.unwrap();
assert_eq!(
incomplete.finish().unwrap_err().kind,
Failure::IncompleteStream
);
let mut unbound = Decoder::default();
assert!(unbound
.event(&chunk(
json!({"tool_calls":[signed_call("call-1")]}),
json!("stop")
))
.is_err());
// Generic chat streams still require an explicit tool finish reason.
let mut ordinary = Decoder::with_binding("binding".into(), false);
assert!(ordinary.event(&chunk(json!({"tool_calls":[{"index":0,"id":"x","type":"function","function":{"name":"app__lookup","arguments":"{}"}}]}), json!("stop"))).is_err());
}
#[test]
fn gemini_conflicting_or_late_signatures_fail_closed() {
let mut d = Decoder::with_binding("binding".into(), true);
let mut call = signed_call("call-1");
call["index"] = json!(0);
d.event(&chunk(json!({"tool_calls":[call]}), Value::Null))
.unwrap();
assert!(d.event(&chunk(json!({"tool_calls":[{"index":0,"extra_content":{"google":{"thought_signature":"DIFFERENT"}}}]}), Value::Null)).is_err());
assert!(d.done().is_err());
let mut late = Decoder::with_binding("binding".into(), true);
late.event(&chunk(json!({"content":"Hi"}), json!("stop")))
.unwrap();
assert!(late
.event(&chunk(
json!({"extra_content":{"google":{"thought_signature":"LATE"}}}),
json!("stop")
))
.is_err());
assert!(late.finish().is_err());
}
#[test]
fn requests_usage_for_streamed_completions() {
let request = body(
"fixture",
"Instructions",
&[json!({"role":"user","content":"Hello"})],
&[],
100,
None,
)
.unwrap();
assert_eq!(request["stream"], true);
assert_eq!(request["stream_options"], json!({"include_usage":true}));
}
fn chunk(delta: Value, reason: Value) -> Value {
json!({"id":"c1","choices":[{"index":0,"delta":delta,"finish_reason":reason}]})
}
fn usage_tail(reason: &str) -> Value {
let mut event = chunk(json!({"role":"assistant","content":""}), json!(reason));
event["choices"][0]["native_finish_reason"] = json!(reason);
event["usage"] = json!({"prompt_tokens":100,"completion_tokens":20,"total_tokens":120,"prompt_tokens_details":{"cached_tokens":80}});
event
}
fn stopped_text() -> Decoder {
let mut decoder = Decoder::default();
assert_eq!(
decoder
.event(&chunk(json!({"content":"Hello"}), json!("stop")))
.unwrap(),
Some("Hello".into())
);
decoder
}
#[test]
fn openrouter_usage_tail_preserves_text_and_accounting() {
let mut decoder = stopped_text();
assert_eq!(decoder.event(&usage_tail("stop")).unwrap(), None);
decoder.done().unwrap();
let result = decoder.finish().unwrap();
assert_eq!(result.output.len(), 1);
assert_eq!(result.output[0]["content"][0]["text"], "Hello");
let usage = result.usage.unwrap();
assert_eq!(
(
usage.input_tokens,
usage.output_tokens,
usage.cached_input_tokens
),
(100, 20, 80)
);
}
#[test]
fn openrouter_usage_tail_preserves_fragmented_tool_call_once() {
let mut decoder = Decoder::default();
decoder.event(&chunk(json!({"tool_calls":[{"index":0,"id":"t1","type":"function","function":{"name":"game__show","arguments":"{\"title\":"}}]}), Value::Null)).unwrap();
decoder
.event(&chunk(
json!({"tool_calls":[{"index":0,"function":{"arguments":"\"hello\"}"}}]}),
json!("tool_calls"),
))
.unwrap();
assert_eq!(decoder.event(&usage_tail("tool_calls")).unwrap(), None);
decoder.done().unwrap();
let result = decoder.finish().unwrap();
assert_eq!(result.output.len(), 1);
assert_eq!(result.output[0]["call_id"], "t1");
assert_eq!(result.output[0]["arguments"], "{\"title\":\"hello\"}");
assert_eq!(result.usage.unwrap().input_tokens, 100);
}
#[test]
fn openai_empty_choices_usage_tail_remains_supported() {
let mut decoder = stopped_text();
let mut tail = usage_tail("stop");
tail["choices"] = json!([]);
assert_eq!(decoder.event(&tail).unwrap(), None);
decoder.done().unwrap();
assert_eq!(decoder.finish().unwrap().usage.unwrap().output_tokens, 20);
}
#[test]
fn accounting_tail_rejects_choice_level_errors() {
for reason in ["stop", "tool_calls"] {
let mut decoder = Decoder::default();
let delta = if reason == "stop" {
json!({"content":"hello"})
} else {
json!({"tool_calls":[{"index":0,"id":"t1","type":"function","function":{"name":"game__show","arguments":"{}"}}]})
};
decoder.event(&chunk(delta, json!(reason))).unwrap();
let mut tail = usage_tail(reason);
tail["choices"][0]["error"] = json!({"code":"server_error"});
assert_eq!(
decoder.event(&tail).unwrap_err().kind,
Failure::InvalidResponse
);
}
}
#[test]
fn accounting_tail_rejects_conflicts_and_new_content() {
let mut cases = vec![];
for delta in [
json!({"content":"late text"}),
json!({"tool_calls":[{"index":0,"function":{"arguments":"{}"}}]}),
json!({"role":"user","content":""}),
json!({"refusal":"blocked"}),
json!({"reasoning":"late reasoning"}),
json!({"function_call":{"name":"unsafe"}}),
Value::Null,
] {
let mut tail = usage_tail("stop");
tail["choices"][0]["delta"] = delta;
cases.push(tail);
}
for reason in ["tool_calls", "length", "content_filter"] {
cases.push(usage_tail(reason));
}
let mut tail = usage_tail("stop");
tail["id"] = json!("another-generation");
cases.push(tail);
let mut tail = usage_tail("stop");
tail.as_object_mut().unwrap().remove("id");
cases.push(tail);
let mut tail = usage_tail("stop");
tail["choices"][0]["index"] = json!(1);
cases.push(tail);
let mut tail = usage_tail("stop");
tail.as_object_mut().unwrap().remove("usage");
cases.push(tail);
let mut tail = usage_tail("stop");
tail["usage"]["prompt_tokens"] = json!("invalid");
cases.push(tail);
let mut tail = usage_tail("stop");
tail["error"] = json!({"message":"failed"});
cases.push(tail);
for tail in cases {
assert!(
stopped_text().event(&tail).is_err(),
"Accepted unsafe accounting tail: {tail}"
);
}
}
#[test]
fn accounting_tail_does_not_replace_done_or_allow_later_events() {
let mut decoder = stopped_text();
decoder.event(&usage_tail("stop")).unwrap();
assert_eq!(
decoder.finish().unwrap_err().kind,
Failure::IncompleteStream
);
let mut decoder = stopped_text();
decoder.event(&usage_tail("stop")).unwrap();
assert!(decoder.event(&usage_tail("stop")).is_err());
assert!(decoder
.event(&chunk(json!({"content":"late"}), Value::Null))
.is_err());
let mut decoder = stopped_text();
decoder.event(&usage_tail("stop")).unwrap();
decoder.done().unwrap();
assert!(decoder.event(&usage_tail("stop")).is_err());
assert!(decoder.done().is_err());
}
#[test]
fn fragmented_call_requires_complete_stream() {
let mut decoder = Decoder::default();
decoder.event(&chunk(json!({"tool_calls":[{"index":0,"id":"t1","type":"function","function":{"name":"game__show","arguments":"{\"title\":"}}]}),Value::Null)).unwrap();
decoder
.event(&chunk(
json!({"tool_calls":[{"index":0,"function":{"arguments":"\"hello\"}"}}]}),
json!("tool_calls"),
))
.unwrap();
decoder.done().unwrap();
let result = decoder.finish().unwrap();
assert_eq!(result.output[0]["arguments"], "{\"title\":\"hello\"}");
let mut incomplete = Decoder::default();
incomplete
.event(&chunk(json!({"content":"x"}), json!("stop")))
.unwrap();
assert_eq!(
incomplete.finish().unwrap_err().kind,
Failure::IncompleteStream
);
}
#[test]
fn truncation_duplicate_calls_and_cross_provider_history_fail_closed() {
let mut decoder = Decoder::default();
assert_eq!(
decoder
.event(&chunk(json!({}), json!("length")))
.unwrap_err()
.kind,
Failure::Truncated
);
assert!(body(
"local:8b",
"system",
&[json!({"type":"reasoning","encrypted_content":"secret"})],
&[],
100,
None
)
.is_err());
assert!(body(
"local:8b",
"system",
&[json!({"type":"function_call_output","call_id":"missing","output":"x"})],
&[],
100,
None
)
.is_err());
}
#[test]
fn roundtrip_tools_and_images() {
let input = vec![
json!({"role":"user","content":[{"type":"input_image","image_url":"data:image/png;base64,abc"}]}),
json!({"type":"function_call","call_id":"t1","name":"game__show","arguments":"{}"}),
json!({"type":"function_call_output","call_id":"t1","output":"ok"}),
];
let b = body(
"org/local:8b",
"system",
&input,
&[json!({"type":"function","name":"game__show","parameters":{"type":"object"}})],
100,
None,
)
.unwrap();
assert_eq!(b["messages"][1]["content"][0]["type"], "image_url");
assert_eq!(b["messages"][3]["tool_call_id"], "t1");
assert_eq!(b["tools"][0]["function"]["name"], "game__show");
}
}