use std::collections::VecDeque;
use bytes::Bytes;
use cpa_common::json as gj;
use cpa_common::thinking::{self, RequestThinking, parse_suffix};
use cpa_core::config::Config;
use cpa_core::credential::Credential;
use cpa_core::exec::{
CaptureEvent, CaptureSink, ExecError, ExecRequest, ExecResponse, ExecStream, FailureScope, Operation, ResponseBody,
UpstreamRequest, UsageSink,
};
use cpa_core::format::Format;
use cpa_translate::{RequestCtx, ResponseCtx, StreamTranslator};
use futures_util::StreamExt;
use crate::gemini_payload as payload;
use crate::gemini_stream::{self as sse, ClaudeInputTokens};
use crate::payload_barrier::Barrier;
use crate::proxy::{self, GoClients, GoHeaders, Hooks, Proxy, Upstream};
pub const PROVIDERS: [&str; 2] = ["gemini", "gemini-interactions"];
pub fn handles(provider: &str) -> bool {
PROVIDERS.contains(&provider)
}
pub(crate) const DEFAULT_BASE_URL: &str = "https://generativelanguage.googleapis.com";
pub(crate) const API_VERSION: &str = "v1beta";
pub(crate) const MAX_LINE: usize = 52_428_800;
const INTERACTIONS_REVISION: &str = "2026-05-20";
pub(crate) const COMPACT_ALT: &str = "responses/compact";
const EMPTY_TRANSLATION: &str = "Invalid apply_patch tool arguments received from upstream.";
pub struct GeminiExecutor {
clients: GoClients,
}
impl Default for GeminiExecutor {
fn default() -> Self {
Self {
clients: GoClients::new(Hooks::default()),
}
}
}
fn scope_for(status: u16) -> FailureScope {
match status {
401 | 402 | 403 | 408 | 429 | 500.. => FailureScope::Credential,
_ => FailureScope::Request,
}
}
pub(crate) fn status_err(status: u16, message: impl Into<Bytes>) -> ExecError {
let mut body: Bytes = message.into();
if body.is_empty() {
body = Bytes::from(format!("status {status}"));
}
ExecError {
status,
scope: scope_for(status),
body,
headers: Box::default(),
retry_after: None,
direct: false,
addon: None,
}
}
pub(crate) fn bad_gateway() -> ExecError {
status_err(502, EMPTY_TRANSLATION)
}
fn api_key(credential: &Credential) -> &str {
credential
.attributes
.get("api_key")
.map(String::as_str)
.unwrap_or_default()
}
fn base_url(credential: &Credential) -> String {
let custom = credential
.attributes
.get("base_url")
.map(|v| v.trim())
.unwrap_or_default();
let base = custom.trim_end_matches('/');
if base.is_empty() {
DEFAULT_BASE_URL.to_owned()
} else {
base.to_owned()
}
}
fn native_interactions(credential: &Credential, source: Format) -> bool {
credential.provider.trim().eq_ignore_ascii_case("gemini-interactions")
&& matches!(
source,
Format::Interactions | Format::OpenAI | Format::OpenAIResponse | Format::Claude | Format::Gemini
)
}
pub(crate) fn alt(req: &ExecRequest) -> Option<&str> {
req.alt.as_deref().filter(|a| !a.is_empty())
}
pub(crate) fn original_request(req: &ExecRequest) -> &Bytes {
if req.original_body.is_empty() {
&req.body
} else {
&req.original_body
}
}
pub(crate) fn translate(
req: &ExecRequest,
cfg: &Config,
target: Format,
model: &str,
body: &[u8],
stream: bool,
compat: bool,
) -> Result<Vec<u8>, ExecError> {
let ctx = RequestCtx {
model,
stream,
tool_search: false,
};
let client = crate::codex_client::Client::new(&req.headers, cfg, "", compat);
deep_stack(body, || {
crate::codex_client::translate_request(req.source_format, target, &ctx, body, &client).map(|t| t.body)
})
.map_err(|e| ExecError::local(400, FailureScope::Request, e.to_string()))
}
pub(crate) fn deep_stack<T: Send>(body: &[u8], f: impl FnOnce() -> T + Send) -> T {
const DEEP: usize = 256;
let (mut depth, mut max, mut in_string, mut escaped) = (0usize, 0usize, false, false);
for &b in body {
if in_string {
match b {
_ if escaped => escaped = false,
b'\\' => escaped = true,
b'"' => in_string = false,
_ => {}
}
continue;
}
match b {
b'"' => in_string = true,
b'{' | b'[' => {
depth += 1;
max = max.max(depth);
}
b'}' | b']' => depth = depth.saturating_sub(1),
_ => {}
}
}
if max <= DEEP {
return f();
}
std::thread::scope(|scope| {
std::thread::Builder::new()
.stack_size(1 << 30)
.spawn_scoped(scope, f)
.map(|handle| handle.join())
})
.ok()
.and_then(Result::ok)
.expect("deep JSON translation thread")
}
fn translate_pair(
req: &ExecRequest,
cfg: &Config,
target: Format,
model: &str,
compat: bool,
) -> Result<(Vec<u8>, Vec<u8>), ExecError> {
let source = original_request(req);
let original = translate(req, cfg, target, model, source, req.stream, compat);
if *source == req.body {
let original = original?;
return Ok((original.clone(), original));
}
let working = translate(req, cfg, target, model, &req.body, req.stream, compat)?;
Ok((crate::translate::baseline_or_working(original, &working), working))
}
pub(crate) fn apply_thinking(
req: &ExecRequest,
body: Vec<u8>,
from: Format,
to: Format,
provider: &str,
resolved: Option<&Resolved>,
) -> Result<Vec<u8>, ExecError> {
thinking::apply_request_thinking(&RequestThinking {
body: &body,
payload: &req.body,
original: &req.original_body,
model: &req.model,
from: from.as_str(),
to: to.as_str(),
provider,
resolved: resolved.map(|r| Some(&r.caps)),
has_request_transformer: cpa_translate::pair(from, to).is_some(),
updates_changed: false,
})
.map_err(|e| ExecError::local(e.status(), FailureScope::Request, e.message))
}
pub(crate) fn count_original(
req: &ExecRequest,
cfg: &Config,
target: Format,
model: &str,
compat: bool,
translated: &[u8],
) -> Result<Vec<u8>, ExecError> {
if req.original_body.is_empty() {
return Ok(translated.to_vec());
}
translate(req, cfg, target, model, &req.original_body, false, compat)
}
fn request_headers(credential: &Credential, req: &ExecRequest) -> GoHeaders {
let mut headers = GoHeaders::new();
headers.set("Content-Type", "application/json");
let key = api_key(credential);
if !key.is_empty() {
headers.set("x-goog-api-key", key);
}
set_custom_headers(&mut headers, credential, req);
headers
}
pub(crate) fn set_custom_headers(headers: &mut GoHeaders, credential: &Credential, req: &ExecRequest) {
let session = cpa_common::session::cpa_session_id(req.session.as_deref());
for (name, value) in cpa_common::headers::custom_headers(&credential.attributes, &req.headers, session.as_deref()) {
headers.set(&name, value);
}
}
pub(crate) fn resolved(req: &ExecRequest) -> Option<Resolved> {
req.resolved_model.as_ref().map(|r| Resolved {
caps: cpa_common::thinking::ModelCaps::from(&r.info),
is_compat: r.is_compat(),
})
}
pub(crate) struct Resolved {
pub caps: cpa_common::thinking::ModelCaps,
pub is_compat: bool,
}
pub(crate) fn capture_request(
capture: &CaptureSink,
credential: &Credential,
provider: &str,
url: &str,
headers: &[(String, String)],
body: &Bytes,
) {
if !capture.enabled() {
return;
}
let (auth_type, auth_value) = cpa_core::registry::dynamic::account_info(credential);
capture.record_request(
UpstreamRequest {
url,
method: "POST",
headers,
body,
provider,
auth_id: &credential.id,
auth_label: &credential.label,
auth_type,
auth_value: &auth_value,
},
body,
);
}
pub(crate) use crate::kimi_http::capture_metadata;
#[allow(clippy::too_many_arguments)]
pub(crate) async fn send_captured(
capture: &CaptureSink,
credential: &Credential,
provider: &str,
client: &wreq::Client,
url: &str,
headers: GoHeaders,
body: Bytes,
lines: bool,
) -> Result<Upstream, ExecError> {
crate::xai_url::new_request(url)?;
capture_request(capture, credential, provider, url, headers.pairs(), &body);
let sent = if let Some(error) = crate::xai_url::transport_refusal(url) {
Err(error)
} else if lines {
proxy::send_scanned(client, url, headers, body, None).await
} else {
proxy::send(client, url, headers, body, None).await
};
match sent {
Ok(upstream) => {
capture_metadata(capture, upstream.status, &upstream.headers);
Ok(upstream)
}
Err(error) => {
capture.record(CaptureEvent::ResponseError(&String::from_utf8_lossy(&error.body)));
Err(error)
}
}
}
pub(crate) async fn read_captured(capture: &CaptureSink, upstream: Upstream, limit: usize) -> Result<Bytes, ExecError> {
match proxy::read_all(upstream.body, limit, false).await {
Ok(data) => {
capture.record(CaptureEvent::ResponseChunk(&data));
Ok(data)
}
Err(error) => {
capture.record(CaptureEvent::ResponseError(&String::from_utf8_lossy(&error.body)));
Err(error)
}
}
}
pub(crate) fn captured_lines(lines: ExecStream, capture: CaptureSink) -> ExecStream {
if !capture.enabled() {
return lines;
}
lines
.inspect(move |item| match item {
Ok(line) => capture.record(CaptureEvent::ResponseChunk(line)),
Err(error) => capture.record(CaptureEvent::ResponseError(&String::from_utf8_lossy(&error.body))),
})
.boxed()
}
pub(crate) async fn error_from(capture: &CaptureSink, upstream: Upstream) -> ExecError {
let status = upstream.status;
let body = proxy::read_all(upstream.body, proxy::MAX_ERROR_BODY, true)
.await
.unwrap_or_default();
capture.record(CaptureEvent::ResponseChunk(&body));
status_err(status, body)
}
async fn read_then_check(capture: &CaptureSink, upstream: Upstream) -> Result<(http::HeaderMap, Bytes), ExecError> {
let status = upstream.status;
let headers = upstream.headers.clone();
let ok = (200..300).contains(&status);
let limit = if ok { usize::MAX } else { proxy::MAX_ERROR_BODY };
let data = read_captured(capture, upstream, limit).await?;
if !ok {
return Err(status_err(status, data));
}
Ok((headers, data))
}
fn identifier(credential: &Credential) -> &'static str {
if credential.provider == "gemini-interactions" {
"gemini-interactions"
} else {
"gemini"
}
}
pub(crate) fn translate_non_stream(
req: &ExecRequest,
upstream: Format,
translated: &[u8],
data: &[u8],
) -> Result<Bytes, ExecError> {
let response = req.response_format;
let ctx = ResponseCtx {
model: &req.model,
original_request: original_request(req),
translated_request: translated,
tool_search: false,
};
let mut out = match cpa_translate::pair(response, upstream) {
Some(pair) => (pair.non_stream)(&ctx, data).map_err(|_| bad_gateway())?,
None => cpa_translate::hooks::unregistered_non_stream(upstream.as_str(), response.as_str(), &ctx, data)
.unwrap_or_else(|| data.to_vec()),
};
if out.is_empty() {
return Err(bad_gateway());
}
if response == Format::OpenAIResponse {
out = crate::openai_compat_payload::ensure_responses_usage_details(&out);
}
Ok(Bytes::from(out))
}
pub(crate) fn claude_error(req: &ExecRequest, out: &[u8]) -> Result<(), ExecError> {
if req.response_format != Format::Claude || *gj::get(out, "type").bytes() != *b"error" {
return Ok(());
}
req.usage.publish_failure_with_usage(502, &String::from_utf8_lossy(out));
Err(status_err(502, Bytes::copy_from_slice(out)))
}
impl GeminiExecutor {
pub fn with_client(client: wreq::Client) -> Self {
Self {
clients: GoClients::with_default(client),
}
}
fn client(&self, credential: &Credential, cfg: &Config) -> wreq::Client {
self.clients.get(&Proxy::effective(credential, cfg))
}
pub async fn execute(
&self,
credential: &Credential,
req: ExecRequest,
cfg: &Config,
) -> Result<ExecResponse, ExecError> {
if req.operation == Operation::CountTokens {
return self.count_tokens(credential, &req, cfg).await;
}
if req.alt.as_deref() == Some(COMPACT_ALT) {
return Err(status_err(501, "/responses/compact not supported"));
}
if native_interactions(credential, req.source_format) {
return self.interactions(credential, &req, cfg).await;
}
self.generate(credential, &req, cfg).await
}
async fn generate(
&self,
credential: &Credential,
req: &ExecRequest,
cfg: &Config,
) -> Result<ExecResponse, ExecError> {
let base_model = parse_suffix(&req.model).model_name;
let (from, to) = (req.source_format, Format::Gemini);
let resolved = resolved(req);
let compat = resolved.as_ref().is_some_and(|r| r.is_compat);
let (original_translated, body) = translate_pair(req, cfg, to, &base_model, compat)?;
let mut body = apply_thinking(req, body, from, to, &credential.provider, resolved.as_ref())?;
body = payload::fix_image_aspect_ratio(&base_model, body);
body = payload::set_str_if_different(body, "model", &base_model);
body = payload::cap_max_output_tokens(body, &base_model);
body = cpa_common::signature::sanitize_gemini_request_thought_signatures(&body, "contents");
body = payload::ensure_leading_user_content(body, "contents");
body = payload::ensure_trailing_user_content(body, "contents");
let action = if req.stream {
"streamGenerateContent"
} else {
"generateContent"
};
let mut url = format!("{}/{API_VERSION}/models/{base_model}:{action}", base_url(credential));
match alt(req) {
Some(alt) => url.push_str(&format!("?$alt={alt}")),
None if req.stream => url.push_str("?alt=sse"),
None => {}
}
body = payload::delete(body, "session_id");
req.usage.request(to, &body);
body = Barrier {
executor: "",
model: &base_model,
protocol: to.as_str(),
root: "",
original: &original_translated,
}
.apply(cfg, req, body);
let headers = request_headers(credential, req);
let capture = req.capture();
let client = self.client(credential, cfg);
let body = Bytes::from(body);
let upstream = send_captured(
capture,
credential,
identifier(credential),
&client,
&url,
headers,
body.clone(),
req.stream,
)
.await?;
if !(200..300).contains(&upstream.status) {
return Err(error_from(capture, upstream).await);
}
let response_headers = upstream.headers.clone();
if !req.stream {
let data = read_captured(capture, upstream, usize::MAX).await?;
req.usage.response_body(to, &data);
let out = translate_non_stream(req, to, &body, &data)?;
claude_error(req, &out)?;
return Ok(ExecResponse {
status: 200,
headers: response_headers,
body: ResponseBody::Buffered(out),
});
}
let output = Output::new(req, to, &body)
.with_claude_stream_errors()
.require_finish_signal()
.fail_on_client_drop(DropRule::Always);
let lines = captured_lines(proxy::lines(upstream.body, MAX_LINE), capture.clone());
let stream = gemini_lines(lines, output, Format::Gemini);
Ok(ExecResponse {
status: 200,
headers: response_headers,
body: ResponseBody::Stream(stream),
})
}
async fn interactions(
&self,
credential: &Credential,
req: &ExecRequest,
cfg: &Config,
) -> Result<ExecResponse, ExecError> {
let body = interactions_body(req, cfg)?;
let url = format!("{}/{API_VERSION}/interactions", base_url(credential));
let mut headers = request_headers(credential, req);
interactions_revision(&mut headers, req);
let client = self.client(credential, cfg);
interactions_exchange(req, credential, identifier(credential), &client, &url, headers, body).await
}
async fn count_tokens(
&self,
credential: &Credential,
req: &ExecRequest,
cfg: &Config,
) -> Result<ExecResponse, ExecError> {
let base_model = parse_suffix(&req.model).model_name;
let (from, to) = (req.source_format, Format::Gemini);
let resolved = resolved(req);
let compat = resolved.as_ref().is_some_and(|r| r.is_compat);
let body = translate(req, cfg, to, &base_model, &req.body, false, compat)?;
let original = count_original(req, cfg, to, &base_model, compat, &body)?;
let mut body = apply_thinking(req, body, from, to, &credential.provider, resolved.as_ref())?;
body = payload::fix_image_aspect_ratio(&base_model, body);
for path in ["tools", "generationConfig", "safetySettings"] {
body = payload::delete(body, path);
}
body = payload::set_str_if_different(body, "model", &base_model);
body = cpa_common::signature::sanitize_gemini_request_thought_signatures(&body, "contents");
body = payload::ensure_leading_user_content(body, "contents");
body = Barrier {
executor: "gemini",
model: &base_model,
protocol: to.as_str(),
root: "",
original: &original,
}
.apply(cfg, req, body);
let url = format!("{}/{API_VERSION}/models/{base_model}:countTokens", base_url(credential));
let headers = request_headers(credential, req);
let capture = req.capture();
let client = self.client(credential, cfg);
let body = Bytes::from(body);
let upstream = send_captured(
capture,
credential,
identifier(credential),
&client,
&url,
headers,
body.clone(),
false,
)
.await?;
let (response_headers, data) = read_then_check(capture, upstream).await?;
let count = gj::get(&data, "totalTokens").int();
let out = cpa_translate::translate_token_count(req.response_format, to, count, &data);
Ok(ExecResponse {
status: 200,
headers: response_headers,
body: ResponseBody::Buffered(Bytes::from(out)),
})
}
}
#[derive(Default)]
pub(crate) struct Emit {
pub(crate) out: Vec<Bytes>,
pub(crate) stop: Option<ExecError>,
}
impl Emit {
pub(crate) fn then(&mut self, next: Emit) -> bool {
self.out.extend(next.out);
self.stop = next.stop;
self.stop.is_some()
}
}
struct Unregistered {
options: cpa_translate::stream::StreamOptions,
hooks: Option<Box<dyn cpa_translate::stream::GoStream>>,
}
impl StreamTranslator for Unregistered {
fn event(&mut self, event: &[u8]) -> Result<Vec<Bytes>, cpa_translate::Error> {
let line = if self.options.whole_events {
event
} else {
event.strip_suffix(LINE_END).unwrap_or(event)
};
let emit = |chunk: &[u8]| match self.options.chunk {
Some(hook) => Bytes::from(hook(chunk)),
None => Bytes::copy_from_slice(chunk),
};
match &mut self.hooks {
Some(hooks) => Ok(hooks.line(line)?.iter().map(|c| emit(c)).collect()),
None => Ok(vec![emit(line)]),
}
}
fn finish(&mut self) -> Result<Vec<Bytes>, cpa_translate::Error> {
Ok(Vec::new())
}
}
pub(crate) struct Output {
translator: Box<dyn StreamTranslator>,
client: Format,
raw: bool,
executor_chunks: bool,
claude: ClaudeInputTokens,
pub(crate) usage: UsageSink,
capture: CaptureSink,
claude_errors: bool,
retained: Option<ExecError>,
drop_rule: DropRule,
finish_signal: Option<bool>,
replay: Option<crate::antigravity_replay::StreamCommit>,
}
#[derive(Clone, Copy, Default, PartialEq, Eq)]
pub(crate) enum DropRule {
#[default]
Off,
Always,
BeforeTerminal { delivered: bool },
Antigravity { delivered: bool },
}
impl Output {
pub(crate) fn new(req: &ExecRequest, upstream: Format, translated: &[u8]) -> Self {
Self::with_options(
req,
upstream,
translated,
cpa_translate::stream::StreamOptions::default(),
)
}
pub(crate) fn with_options(
req: &ExecRequest,
upstream: Format,
translated: &[u8],
options: cpa_translate::stream::StreamOptions,
) -> Self {
let client = req.response_format;
let ctx = ResponseCtx {
model: &req.model,
original_request: original_request(req),
translated_request: translated,
tool_search: false,
};
let mut translator = cpa_translate::stream_with(client, upstream, &ctx, options).unwrap_or_else(|| {
Box::new(Unregistered {
options,
hooks: cpa_translate::hooks::wrap_stream(upstream.as_str(), client.as_str(), &ctx, None),
})
});
if req.stream_payloads {
translator.executor_chunks();
}
Self {
translator,
client,
raw: alt(req).is_some(),
executor_chunks: req.stream_payloads,
claude: ClaudeInputTokens::new(req.source_format, upstream, client, original_request(req).clone()),
usage: req.usage.clone(),
capture: req.capture().clone(),
claude_errors: false,
retained: None,
drop_rule: DropRule::Off,
finish_signal: None,
replay: None,
}
}
pub(crate) fn require_finish_signal(mut self) -> Self {
if self.client == Format::Claude {
self.finish_signal = Some(false);
}
self
}
pub(crate) fn observe_finish_signal(&mut self, line: &[u8]) {
if self.finish_signal != Some(false) {
return;
}
let Some(payload) = sse::json_payload(line) else {
return;
};
let seen = [
"candidates.#.finishReason",
"response.candidates.#.finishReason",
"promptFeedback.blockReason",
"response.promptFeedback.blockReason",
]
.iter()
.any(|path| {
gj::get(payload, *path)
.array()
.iter()
.any(|item| !cpa_common::gostr::trim_space(&item.bytes()).is_empty())
});
self.finish_signal = Some(seen);
}
pub(crate) fn with_replay(mut self, commit: crate::antigravity_replay::StreamCommit) -> Self {
self.replay = Some(commit);
self
}
pub(crate) fn fail_on_client_drop(mut self, rule: DropRule) -> Self {
self.drop_rule = rule;
self
}
pub(crate) fn with_claude_stream_errors(mut self) -> Self {
self.claude_errors = self.client == Format::Claude;
self
}
fn client_dropped(&self) {
let (fail, with_usage) = match self.drop_rule {
DropRule::Off => (false, false),
DropRule::Always => (true, false),
DropRule::BeforeTerminal { delivered } => (!delivered, false),
DropRule::Antigravity { delivered } => (!delivered, true),
};
if fail {
self.capture.record(CaptureEvent::ResponseError("context canceled"));
if with_usage {
self.usage.publish_failure_with_usage(499, "context canceled");
} else {
self.usage.publish_failure(499, "context canceled");
}
}
}
pub(crate) fn stop_retained(&mut self, emit: &mut Emit) -> bool {
if emit.stop.is_some() {
return true;
}
let Some(error) = self.retained.take() else {
return false;
};
self.usage
.publish_failure_with_usage(error.status, &String::from_utf8_lossy(&error.body));
emit.stop = Some(error);
true
}
fn capture_claude_error(&mut self, out: &[Bytes]) {
if !self.claude_errors || self.retained.is_some() {
return;
}
let payload = out
.iter()
.flat_map(|chunk| chunk.split(|b| *b == b'\n'))
.find_map(|line| {
crate::gemini_stream::json_payload(line).filter(|p| *gj::get(p, "type").bytes() == *b"error")
});
if let Some(payload) = payload {
self.retained = Some(status_err(502, Bytes::copy_from_slice(payload)));
}
}
pub(crate) fn with_claude_original(mut self, original: Bytes) -> Self {
self.claude = self.claude.with_original(original);
self
}
pub(crate) fn end(&mut self) -> Emit {
let mut emit = self.finalize();
if !self.stop_retained(&mut emit) {
emit.then(self.finish());
}
emit
}
pub(crate) fn end_with_done(&mut self) -> Emit {
let mut emit = self.finalize();
if self.stop_retained(&mut emit) {
return emit;
}
if self.finish_signal == Some(false) {
let error = status_err(502, "upstream stream closed before finishReason");
let message = String::from_utf8_lossy(&error.body).into_owned();
self.capture.record(CaptureEvent::ResponseError(&message));
self.usage.publish_failure_with_usage(error.status, &message);
emit.stop = Some(error);
return emit;
}
if !emit.then(self.translate(b"[DONE]")) && !self.stop_retained(&mut emit) {
if let Some(replay) = &mut self.replay {
replay.commit();
}
emit.then(self.finish());
}
emit
}
pub(crate) fn end_after_error(&mut self) -> Emit {
let mut emit = self.finalize();
self.stop_retained(&mut emit);
emit
}
pub(crate) fn translate(&mut self, payload: &[u8]) -> Emit {
let mut out = match self.translator.event(payload) {
Ok(out) => out,
Err(_) => return self.failed(),
};
self.frame(&mut out);
self.post_process(&mut out);
self.capture_claude_error(&out);
match &mut self.drop_rule {
DropRule::BeforeTerminal { delivered } if !*delivered => {
*delivered = out.iter().any(|chunk| is_terminal_chunk(chunk));
}
DropRule::Antigravity { delivered } if !*delivered => {
let finished = ["candidates.0.finishReason", "response.candidates.0.finishReason"]
.iter()
.any(|path| !cpa_common::gostr::trim_space(&gj::get(payload, *path).bytes()).is_empty());
*delivered = finished || out.iter().any(|chunk| is_terminal_chunk(chunk));
if let Some(replay) = &mut self.replay {
replay.terminal = *delivered;
}
}
_ => {}
}
let emit = self.checked(out);
if self.client == Format::OpenAIResponse
&& let Some(replay) = &mut self.replay
&& emit.out.iter().any(|chunk| {
chunk.split(|b| *b == b'\n').any(|line| {
sse::json_payload(line).is_some_and(|p| *gj::get(p, "type").bytes() == *b"response.completed")
})
})
{
replay.commit_if_terminal();
}
emit
}
fn finalize(&mut self) -> Emit {
let mut out = self.translator.finalize_tool_input();
self.frame(&mut out);
self.checked(out)
}
fn finish(&mut self) -> Emit {
let mut out = match self.translator.finish() {
Ok(out) => out,
Err(_) => return self.failed(),
};
self.frame(&mut out);
self.post_process(&mut out);
self.checked(out)
}
pub(crate) fn flush_frames(&mut self) -> Vec<Bytes> {
let mut out = self.translator.flush_frames();
self.frame(&mut out);
self.post_process(&mut out);
out
}
fn checked(&mut self, out: Vec<Bytes>) -> Emit {
if self.translator.tool_input_failed() {
let mut emit = self.failed();
emit.out = out;
return emit;
}
Emit { out, stop: None }
}
fn failed(&mut self) -> Emit {
if let Some(replay) = &mut self.replay {
replay.failed = true;
}
Emit {
out: Vec::new(),
stop: Some(bad_gateway()),
}
}
fn frame(&self, out: &mut Vec<Bytes>) {
if self.client == Format::Gemini && !self.executor_chunks {
for chunk in out.iter_mut() {
let bare = chunk
.strip_prefix(b"data: ")
.and_then(|c| c.strip_suffix(b"\n\n"))
.map_or_else(|| chunk.clone(), Bytes::copy_from_slice);
*chunk = if self.raw {
bare
} else {
let mut framed = Vec::with_capacity(bare.len() + 8);
framed.extend_from_slice(b"data: ");
framed.extend_from_slice(&bare);
framed.extend_from_slice(b"\n\n");
Bytes::from(framed)
};
}
}
out.retain(|c| !c.is_empty());
}
fn post_process(&mut self, out: &mut [Bytes]) {
if self.client == Format::OpenAIResponse {
for chunk in out.iter_mut() {
*chunk = Bytes::from(crate::openai_compat_payload::ensure_responses_usage_details(chunk));
}
}
self.claude.apply(out);
}
}
pub(crate) trait LineState: Send + 'static {
fn line(&mut self, line: &[u8]) -> Emit;
fn end(&mut self) -> Emit;
fn end_after_error(&mut self) -> Emit {
self.end()
}
fn flush(&mut self) -> Vec<Bytes>;
fn output(&self) -> Option<&Output> {
None
}
}
pub(crate) fn drive<S: LineState>(lines: ExecStream, state: S) -> ExecStream {
futures_util::stream::unfold(
(
lines,
Driven { state, settled: false },
VecDeque::<Result<Bytes, ExecError>>::new(),
),
|(mut lines, mut driven, mut ready)| async move {
loop {
if let Some(item) = ready.pop_front() {
if item.is_err() {
ready.clear();
}
return Some((item, (lines, driven, ready)));
}
if driven.settled {
return None;
}
let scanned = lines.next().await;
let state = &mut driven.state;
let emit = match &scanned {
Some(Ok(line)) => state.line(line),
Some(Err(_)) => {
driven.settled = true;
state.end_after_error()
}
None => {
driven.settled = true;
state.end()
}
};
ready.extend(emit.out.into_iter().map(Ok));
let error = match (emit.stop, scanned) {
(Some(error), _) | (None, Some(Err(error))) => error,
_ => continue,
};
driven.settled = true;
ready.extend(state.flush().into_iter().map(Ok));
ready.push_back(Err(error));
}
},
)
.boxed()
}
fn is_terminal_chunk(chunk: &[u8]) -> bool {
chunk.split(|b| *b == b'\n').any(|line| {
let trimmed = cpa_common::gostr::trim_space(line);
if trimmed == b"data: [DONE]" || trimmed == b"[DONE]" {
return true;
}
let Some(payload) = sse::json_payload(line) else {
return false;
};
let kind = gj::get(payload, "type").bytes();
if matches!(
kind.as_ref(),
b"response.completed" | b"response.incomplete" | b"response.done" | b"message_stop"
) {
return true;
}
[
"choices.0.finish_reason",
"response.choices.0.finish_reason",
"candidates.0.finishReason",
"response.candidates.0.finishReason",
]
.iter()
.any(|path| {
let reason = gj::get(payload, *path);
reason.exists() && !cpa_common::gostr::trim_space(&reason.bytes()).is_empty()
})
})
}
struct Driven<S: LineState> {
state: S,
settled: bool,
}
impl<S: LineState> Drop for Driven<S> {
fn drop(&mut self) {
if !self.settled
&& let Some(output) = self.state.output()
{
output.client_dropped();
}
}
}
struct GeminiLines {
output: Output,
upstream: Format,
}
impl LineState for GeminiLines {
fn line(&mut self, line: &[u8]) -> Emit {
if self.upstream != Format::Antigravity {
self.output.usage.response_line(self.upstream, line);
self.output.observe_finish_signal(line);
let filtered = sse::filter_sse_usage_metadata(line);
return match sse::json_payload(&filtered) {
Some(payload) => self.output.translate(payload),
None => Emit::default(),
};
}
let assembled = line.contains(&b'\n');
if !assembled {
self.output.usage.response_line(self.upstream, line);
}
let Some(payload) = sse::json_payload(line) else {
return Emit::default();
};
let error = gj::get(payload, "error");
if error.exists() {
let code = error.get("code").int();
let status = u16::try_from(code)
.ok()
.filter(|c| (400..=599).contains(c))
.unwrap_or(502);
let error = crate::antigravity::upstream_error(status, Bytes::copy_from_slice(payload));
self.output
.capture
.record(CaptureEvent::ResponseError(&String::from_utf8_lossy(&error.body)));
return Emit {
out: Vec::new(),
stop: Some(error),
};
}
if assembled {
self.output.usage.response_model_line(payload);
}
self.output.translate(payload)
}
fn end(&mut self) -> Emit {
self.output.end_with_done()
}
fn end_after_error(&mut self) -> Emit {
self.output.end_after_error()
}
fn flush(&mut self) -> Vec<Bytes> {
self.output.flush_frames()
}
fn output(&self) -> Option<&Output> {
Some(&self.output)
}
}
pub(crate) fn gemini_lines(lines: ExecStream, output: Output, upstream: Format) -> ExecStream {
drive(lines, GeminiLines { output, upstream })
}
pub(crate) fn antigravity_payloads(lines: ExecStream) -> ExecStream {
lines
.scan(Vec::<u8>::new(), |pending, item| {
let line = match item {
Ok(line) => line,
Err(error) => return std::future::ready(Some(Some(Err(error)))),
};
let filtered = sse::filter_sse_usage_metadata(&line);
let out = if pending.is_empty() {
match sse::json_payload(&filtered) {
Some(payload) if !gj::valid(payload) => {
*pending = payload.to_vec();
None
}
_ => Some(Bytes::from(filtered)),
}
} else {
let mut piece = cpa_common::gostr::trim_space(&filtered);
if let Some(rest) = piece.strip_prefix(b"data:") {
piece = cpa_common::gostr::trim_space(rest);
}
if !piece.is_empty() {
pending.push(b'\n');
pending.extend_from_slice(piece);
}
(piece.ends_with(b"}") && gj::valid(pending)).then(|| Bytes::from(std::mem::take(pending)))
};
std::future::ready(Some(out.map(Ok)))
})
.filter_map(std::future::ready)
.boxed()
}
pub(crate) const LINE_END: &[u8] = b"\r\n";
pub(crate) fn line_event(line: &[u8]) -> Vec<u8> {
[line, LINE_END].concat()
}
pub(crate) fn interactions_body(req: &ExecRequest, cfg: &Config) -> Result<Bytes, ExecError> {
let target = parse_suffix(&req.model).model_name;
let (from, to) = (req.source_format, Format::Interactions);
let resolved = resolved(req);
let compat = resolved.as_ref().is_some_and(|r| r.is_compat);
let (original_translated, mut body) = if from == Format::Interactions {
(original_request(req).to_vec(), req.body.to_vec())
} else {
translate_pair(req, cfg, to, &target, compat)?
};
if gj::get(&body, "model").exists() && !target.is_empty() {
body = payload::set_str_if_different(body, "model", &target);
}
body = apply_thinking(req, body, from, to, "gemini", resolved.as_ref())?;
body = payload::sanitize_interactions_input_ids(body);
if req.stream {
body = payload::set_bool_if_different(body, "stream", true);
}
body = Barrier {
executor: "",
model: &target,
protocol: "interactions",
root: "",
original: &original_translated,
}
.apply(cfg, req, body);
Ok(Bytes::from(body))
}
pub(crate) fn interactions_revision(headers: &mut GoHeaders, req: &ExecRequest) {
if headers.get("Api-Revision").is_none_or(str::is_empty)
&& let Some(revision) = req
.headers
.get("Api-Revision")
.and_then(|v| v.to_str().ok())
.filter(|v| !v.is_empty())
{
headers.set("Api-Revision", revision);
}
if headers.get("Api-Revision").is_none_or(str::is_empty) {
headers.set("Api-Revision", INTERACTIONS_REVISION);
}
}
pub(crate) async fn interactions_exchange(
req: &ExecRequest,
credential: &Credential,
provider: &str,
client: &wreq::Client,
url: &str,
headers: GoHeaders,
body: Bytes,
) -> Result<ExecResponse, ExecError> {
let to = Format::Interactions;
let capture = req.capture();
let upstream = send_captured(
capture,
credential,
provider,
client,
url,
headers,
body.clone(),
req.stream,
)
.await?;
if !req.stream {
let (response_headers, data) = read_then_check(capture, upstream).await?;
req.usage.response_body(to, &data);
let out = translate_non_stream(req, to, &body, &data)?;
return Ok(ExecResponse {
status: 200,
headers: response_headers,
body: ResponseBody::Buffered(out),
});
}
if !(200..300).contains(&upstream.status) {
return Err(error_from(capture, upstream).await);
}
let response_headers = upstream.headers.clone();
let output = Output::new(req, to, &body).fail_on_client_drop(DropRule::Always);
let lines = captured_lines(proxy::lines(upstream.body, MAX_LINE), capture.clone());
let stream = interactions_lines(lines, output);
Ok(ExecResponse {
status: 200,
headers: response_headers,
body: ResponseBody::Stream(stream),
})
}
struct InteractionsLines {
output: Output,
frame: Option<Vec<u8>>,
}
impl InteractionsLines {
fn report_frame(&mut self) {
if let Some(frame) = &mut self.frame {
let payload = cpa_translate::stream::interactions_frame_payload(frame);
frame.clear();
if !payload.is_empty() {
self.output.usage.response_line(Format::Interactions, &payload);
}
}
}
}
impl LineState for InteractionsLines {
fn line(&mut self, line: &[u8]) -> Emit {
if self.frame.is_some() {
if line.trim_ascii().is_empty() {
self.report_frame();
} else if let Some(frame) = &mut self.frame {
if !frame.is_empty() {
frame.push(b'\n');
}
frame.extend_from_slice(line);
}
}
self.output.translate(&line_event(line))
}
fn end(&mut self) -> Emit {
self.report_frame();
let mut emit = self.output.translate(b"\n");
if emit.stop.is_none() && !emit.then(self.output.finalize()) {
emit.then(self.output.finish());
}
emit
}
fn flush(&mut self) -> Vec<Bytes> {
self.output.flush_frames()
}
fn output(&self) -> Option<&Output> {
Some(&self.output)
}
}
fn interactions_lines(lines: ExecStream, output: Output) -> ExecStream {
let frame = output.usage.enabled().then(Vec::new);
drive(lines, InteractionsLines { output, frame })
}
#[cfg(test)]
#[path = "gemini_tests.rs"]
pub(crate) mod tests;