//! Nonpersistent Responses codec (`SMH-SPEC-PLUG0001`, `SMH-SPEC-SPEC0001`). //! //! No credential effect or provider registration is supplied here. //! Activating this codec requires the separately validated OAuth module binding. #![deny(unsafe_code)] #[expect(clippy::pedantic, reason = "wit-bindgen generates component ABI glue")] #[allow( unsafe_code, reason = "wit-bindgen owns component ABI glue; no authored unsafe code" )] mod bindings { wit_bindgen::generate!({ path: "../../wit/smith-plugin.wit", world: "responses-world", }); use super::ResponsesProtocol; export!(ResponsesProtocol with_types_in self); } use bindings::exports::smith::plugin::plugin::{Guest as PluginGuest, ToolDeclaration}; use bindings::exports::smith::plugin::protocol_openai_responses_v1::Guest as ResponsesBindingGuest; use bindings::exports::smith::plugin::provider::{ CatalogSnapshot, DecodeStep, Guest as ProviderGuest, MessageBlock, MessageRole, ProviderMessage, ProviderRequest, ProviderSettings, RequestTemplate, SettingsProvenance, StopReason, StreamEvent, ToolUse, Usage, }; use bindings::exports::smith::plugin::registration::{Guest as RegistrationGuest, Registrations}; use serde_json::{Value, json}; const REQUEST_TEXT_BYTES_MAX: usize = 64 * 1024; const REQUEST_ITEMS_MAX: usize = 128; const FRAME_BYTES_MAX: usize = 64 * 1024; const CHUNK_BYTES_MAX: usize = 256 * 1024; const STATE_HEADER_BYTES: usize = 18; const OUTPUT_ITEMS_MAX: u64 = 128; const TOOL_NAMESPACE: &str = "smith"; struct ResponsesProtocol; impl ResponsesBindingGuest for ResponsesProtocol { fn credential_source() -> String { "openai-chatgpt-plan@1".into() } } impl RegistrationGuest for ResponsesProtocol { fn declare() -> Registrations { Registrations { credential_sources: Vec::new(), providers: Vec::new(), models: Vec::new(), } } } impl PluginGuest for ResponsesProtocol { fn declare_tools() -> Vec { Vec::new() } fn invoke(_name: String, _input_json: String) -> Result { Err("protocol declares no tools".into()) } } impl ProviderGuest for ResponsesProtocol { fn declare_settings() -> ProviderSettings { ProviderSettings { include_usage: true, subscription: false, provenance: SettingsProvenance::BuiltIn, } } fn validate_settings(settings: ProviderSettings) -> Result { if !settings.include_usage { return Err("Responses usage reporting cannot be disabled".into()); } Ok(settings) } fn build_request( model: String, request: ProviderRequest, settings: ProviderSettings, catalog: CatalogSnapshot, ) -> Result { Self::validate_settings(settings)?; validate_request(&model, &request, &catalog)?; let mut input = Vec::new(); for message in &request.messages { encode_message(message, &mut input)?; } let mut body = json!({"model":model, "input":input, "store":false, "stream":true}); if !request.tools.is_empty() { let mut tools = Vec::with_capacity(request.tools.len()); for tool in &request.tools { if !valid_name(&tool.name) { return Err("invalid function tool name".into()); } let parameters: Value = serde_json::from_str(&tool.input_schema_json) .map_err(|_| "function tool schema is not JSON")?; if parameters.get("type").and_then(Value::as_str) != Some("object") { return Err("function tool schema must describe an object".into()); } tools.push(json!({ "type":"function", "name":tool.name, "description":tool.description, "parameters":parameters, "strict":false, })); } body["tools"] = json!([{ "type":"namespace", "name":TOOL_NAMESPACE, "description":"Smith local coding tools", "tools":tools, }]); } Ok(RequestTemplate { url: "https://protocol.invalid/responses".into(), authorization: "Bearer {{secret:connection-oauth}}".into(), body: body.to_string(), }) } fn decode_response( state: Vec, chunk: Vec, finished: bool, ) -> Result { if chunk.len() > CHUNK_BYTES_MAX { return Err("Responses chunk exceeds byte limit".into()); } let mut decoder = Decoder::restore(&state)?; let mut events = Vec::new(); for fragment in chunk.split_inclusive(|byte| *byte == b'\n') { if decoder.pending.len() + fragment.len() > FRAME_BYTES_MAX { return Err("Responses SSE frame exceeds byte limit".into()); } decoder.pending.extend_from_slice(fragment); if fragment.last() != Some(&b'\n') { continue; } let line_end = decoder.pending.len() - 1; let line_start = decoder.pending[..line_end] .iter() .rposition(|byte| *byte == b'\n') .map_or(0, |index| index + 1); if !decoder.pending[line_start..line_end] .iter() .all(|byte| *byte == b'\r') { continue; } let data = sse_data(&decoder.pending)?; if !data.is_empty() { decoder.event(&data, &mut events)?; if events.len() > REQUEST_ITEMS_MAX { return Err("Responses decoded event count exceeds limit".into()); } } decoder.pending.clear(); } if finished && (!decoder.completed || !decoder.pending.is_empty()) { return Err("Responses stream ended without complete response.completed frame".into()); } Ok(DecodeStep { state: decoder.save(), events, }) } } fn valid_name(name: &str) -> bool { !name.is_empty() && name.len() <= 64 && name .bytes() .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-')) } fn validate_request( model: &str, request: &ProviderRequest, catalog: &CatalogSnapshot, ) -> Result<(), String> { if model.is_empty() || model.len() > 256 || !model .bytes() .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-')) { return Err("invalid Responses model".into()); } let selected = catalog .models .iter() .find(|entry| entry.id == model) .ok_or("account catalog does not admit Responses model")?; if selected.capabilities.thinking { return Err("this Responses protocol version does not support reasoning models".into()); } if request.output_tokens_max.is_some() { return Err("ChatGPT plan does not support max_output_tokens".into()); } if !request.tools.is_empty() && !selected.capabilities.tool_use { return Err("account catalog does not admit function tools".into()); } if request.messages.len() > REQUEST_ITEMS_MAX || request.tools.len() > REQUEST_ITEMS_MAX { return Err("Responses request item count exceeds limit".into()); } let mut bytes = 0_usize; let mut items = request.tools.len(); for message in &request.messages { items = items.saturating_add(message.blocks.len()); for block in &message.blocks { bytes = bytes.saturating_add(match block { MessageBlock::Text(text) | MessageBlock::Thinking(text) => text.len(), MessageBlock::ToolUse(call) => call .name .len() .saturating_add(call.call_id.len()) .saturating_add(call.input_json.len()), MessageBlock::ToolResult(result) => result .name .len() .saturating_add(result.call_id.len()) .saturating_add(result.output.len()), }); } } for tool in &request.tools { bytes = bytes .saturating_add(tool.name.len()) .saturating_add(tool.description.len()) .saturating_add(tool.input_schema_json.len()); } if bytes > REQUEST_TEXT_BYTES_MAX || items > REQUEST_ITEMS_MAX { return Err("Responses request exceeds text or item limit".into()); } Ok(()) } fn encode_message(message: &ProviderMessage, input: &mut Vec) -> Result<(), String> { let role = match message.role { MessageRole::System => "developer", MessageRole::User => "user", MessageRole::Assistant => "assistant", MessageRole::Tool => "tool", }; for block in &message.blocks { match block { MessageBlock::Text(text) if role != "tool" => { input.push(json!({"role":role, "content":text})); } MessageBlock::ToolUse(call) if role == "assistant" => { let arguments: Value = serde_json::from_str(&call.input_json) .map_err(|_| "function arguments are not JSON")?; if !arguments.is_object() || !valid_name(&call.name) || call.call_id.is_empty() { return Err("invalid function call history".into()); } input.push(json!({ "type":"function_call", "call_id":call.call_id, "name":call.name, "namespace":TOOL_NAMESPACE, "arguments":call.input_json, })); } MessageBlock::ToolResult(result) if role == "tool" && !result.call_id.is_empty() => { input.push(json!({"type":"function_call_output", "call_id":result.call_id, "output":result.output})); } _ => return Err("unsupported Responses message block or role".into()), } } Ok(()) } /// Invocation scratch only; host carries the bounded serialized state between chunks. struct Decoder { pending: Vec, tool_indexes: u128, completed: bool, refusal: bool, } impl Decoder { fn restore(state: &[u8]) -> Result { if state.is_empty() { return Ok(Self { pending: Vec::new(), tool_indexes: 0, completed: false, refusal: false, }); } if state.len() < STATE_HEADER_BYTES || state.len() > STATE_HEADER_BYTES + FRAME_BYTES_MAX || state[0] != 1 || state[1] & !3 != 0 { return Err("invalid Responses codec state".into()); } let indexes: [u8; 16] = state[2..STATE_HEADER_BYTES] .try_into() .map_err(|_| "invalid Responses codec state")?; Ok(Self { pending: state[STATE_HEADER_BYTES..].to_vec(), tool_indexes: u128::from_le_bytes(indexes), completed: state[1] & 1 != 0, refusal: state[1] & 2 != 0, }) } fn save(&self) -> Vec { let mut state = Vec::with_capacity(STATE_HEADER_BYTES + self.pending.len()); state.push(1); state.push(u8::from(self.completed) | (u8::from(self.refusal) << 1)); state.extend_from_slice(&self.tool_indexes.to_le_bytes()); state.extend_from_slice(&self.pending); state } fn event(&mut self, data: &str, events: &mut Vec) -> Result<(), String> { if self.completed { return Err("Responses event after response.completed".into()); } let event: Value = serde_json::from_str(data).map_err(|_| "Responses event is not JSON")?; let kind = event .get("type") .and_then(Value::as_str) .ok_or("Responses event has no type")?; match kind { "response.output_text.delta" | "response.refusal.delta" => { let refusal = kind == "response.refusal.delta"; let text = event .get("delta") .and_then(Value::as_str) .ok_or(if refusal { "invalid Responses refusal delta" } else { "invalid Responses text delta" })?; self.refusal |= refusal; if !text.is_empty() { events.push(StreamEvent::Text(text.into())); } } "response.output_item.done" => self.item(&event, events)?, "response.completed" => { let response = event .get("response") .ok_or("Responses completion has no response")?; if response.get("status").and_then(Value::as_str) != Some("completed") { return Err("Responses completion status is not completed".into()); } let usage = response .get("usage") .ok_or("Responses completion has no usage")?; let input_tokens = usage .get("input_tokens") .and_then(Value::as_u64) .ok_or("invalid Responses input usage")?; let output_tokens = usage .get("output_tokens") .and_then(Value::as_u64) .ok_or("invalid Responses output usage")?; let cached = match usage .get("input_tokens_details") .and_then(|details| details.get("cached_tokens")) { None => 0, Some(value) => value.as_u64().ok_or("invalid Responses cache usage")?, }; if cached > input_tokens { return Err("Responses cached usage exceeds input usage".into()); } let reason = if self.tool_indexes != 0 { StopReason::ToolUse } else if self.refusal { StopReason::Refusal } else { StopReason::EndTurn }; events.push(StreamEvent::Stop(( reason, Some(Usage { input_tokens, output_tokens, input_cache_hit_tokens: cached, input_cache_write_tokens: 0, }), ))); self.completed = true; } "response.failed" | "response.incomplete" | "error" => { let error = event .get("response") .and_then(|response| response.get("error")) .unwrap_or(&event); let code = error.get("code").and_then(Value::as_str).filter(|code| { code.len() <= 128 && code .bytes() .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_') }); return Err(code.map_or_else( || format!("Responses terminal failure: {kind}"), |code| format!("Responses terminal failure: {kind} ({code})"), )); } "response.created" | "response.in_progress" | "response.output_item.added" | "response.content_part.added" | "response.content_part.done" | "response.output_text.done" | "response.refusal.done" | "response.function_call_arguments.delta" | "response.function_call_arguments.done" => {} _ => return Err("unsupported Responses stream event".into()), } Ok(()) } fn item(&mut self, event: &Value, events: &mut Vec) -> Result<(), String> { let item = event.get("item").ok_or("Responses output item missing")?; match item.get("type").and_then(Value::as_str) { Some("message") => return Ok(()), Some("function_call") => {} _ => return Err("unsupported Responses output item".into()), } let index = event .get("output_index") .and_then(Value::as_u64) .filter(|index| *index < OUTPUT_ITEMS_MAX) .ok_or("invalid Responses output index")?; let bit = 1_u128 << index; if self.tool_indexes & bit != 0 { return Err("duplicate Responses function output item".into()); } if item.get("status").and_then(Value::as_str) != Some("completed") { return Err("incomplete Responses function output item".into()); } if item.get("namespace").and_then(Value::as_str) != Some(TOOL_NAMESPACE) { return Err("Responses function uses an unadvertised namespace".into()); } let name = item .get("name") .and_then(Value::as_str) .filter(|name| valid_name(name)) .ok_or("invalid Responses function name")?; let call_id = item .get("call_id") .and_then(Value::as_str) .filter(|id| !id.is_empty()) .ok_or("invalid Responses function call id")?; let arguments = item .get("arguments") .and_then(Value::as_str) .ok_or("Responses function arguments missing")?; let parsed: Value = serde_json::from_str(arguments) .map_err(|_| "Responses function arguments are not JSON")?; if !parsed.is_object() { return Err("Responses function arguments must be an object".into()); } events.push(StreamEvent::ToolUse(ToolUse { name: name.into(), call_id: call_id.into(), input_json: arguments.into(), })); self.tool_indexes |= bit; Ok(()) } } fn sse_data(frame: &[u8]) -> Result { let text = std::str::from_utf8(frame).map_err(|_| "Responses SSE frame is not UTF-8")?; let mut data = String::new(); for line in text.split('\n') { let line = line.strip_suffix('\r').unwrap_or(line); if let Some(value) = line.strip_prefix("data:") { if !data.is_empty() { data.push('\n'); } data.push_str(value.strip_prefix(' ').unwrap_or(value)); } } Ok(data) } #[cfg(test)] mod tests;