fix: align custom tool SSE lifecycle with OpenAI API compatibility (vllm-project#158)

## Summary

This PR fixes custom tool support across the gateway while preserving
OpenAI’s public Responses API contract.

## What was wrong

vLLM accepts a `type: "custom"` declaration, but exposes the resulting
call as a regular `function_call`. Its streaming response emits:

- `response.function_call_arguments.delta`
- `response.function_call_arguments.done`

It does not emit OpenAI-compatible custom-tool events:

- `response.custom_tool_call_input.delta`
- `response.custom_tool_call_input.done`

Forwarding vLLM’s response directly therefore leaked the internal
normalized function shape instead of returning a public
`custom_tool_call`.

## What changed

The gateway now:

- Normalizes custom tools into model-facing function tools with a
required string `input` parameter.
- Keeps custom tools client-owned; the gateway does not execute them.
- Hides vLLM’s internal normalized function-call events.
- Restores blocking output as `custom_tool_call`.
- Emits the OpenAI-compatible streaming lifecycle:
  - `response.output_item.added`
  - `response.custom_tool_call_input.delta`
  - `response.custom_tool_call_input.done`
  - `response.output_item.done`
- Uses one stable `ctc_` item ID throughout the lifecycle.
- Converts custom call/output history into the normalized function
representation only when sending continuation context upstream.

## Testing

Added OpenAI and gateway cassettes for streaming and non-streaming
two-turn custom-tool flows. Tests verify:

- Gateway output matches OpenAI’s public custom-tool contract.
- Raw custom input is preserved.
- Internal `function_call` items do not leak.
- Streaming lifecycle IDs and sequence numbers remain consistent.
- `custom_tool_call_output` works correctly on the continuation turn.

---------

Signed-off-by: maral <maralbahari.98@gmail.com>

Author: maralbahari

crates/agentic-server-core/src/executor/accumulator.rs

@@ -86,9 +86,9 @@ fn item_has_meaningful_context(item: &InputItem) -> bool {
             }),
         },
         InputItem::FunctionCall(call) => !call.name.trim().is_empty() || !call.arguments.trim().is_empty(),
-        InputItem::FunctionCallOutput(output) => !output.output.trim().is_empty(),
+        InputItem::FunctionCallOutput(output) => output.output.has_content(),
         InputItem::CustomToolCall(call) => !call.name.trim().is_empty() || !call.input.trim().is_empty(),
-        InputItem::CustomToolCallOutput(output) => value_has_content(&output.output),
+        InputItem::CustomToolCallOutput(output) => output.output.has_content(),
         InputItem::Reasoning(reasoning) => {
             reasoning.content.iter().any(|content| !content.text.trim().is_empty())
                 || reasoning.summary.iter().any(value_has_content)
@@ -391,7 +391,7 @@ mod tests {
             user_message("first"),
             InputItem::FunctionCallOutput(FunctionToolResultMessage {
                 call_id: "call_1".to_owned(),
-                output: "tool output".to_owned(),
+                output: "tool output".into(),
             }),
             user_message("second"),
         ];
@@ -428,7 +428,7 @@ mod tests {
             user_message("hello context"),
             InputItem::FunctionCallOutput(FunctionToolResultMessage {
                 call_id: "call_1".to_owned(),
-                output: "substantial tool output".to_owned(),
+                output: "substantial tool output".into(),
             }),
         ]);
 

crates/agentic-server-core/src/executor/compaction.rs

@@ -17,7 +17,7 @@ use super::gateway::{
     GatewayCallResult, LoopDecision, append_gateway_calls_to_new_input, append_output_items_to_input,
     append_tool_outputs, classify_round, emit_gateway_completed_events, emit_gateway_start_events,
     execute_and_emit_output_calls, execute_output_calls, gateway_event_plans, has_client_owned_calls,
-    is_gateway_owned_call, public_output_items,
+    is_client_custom_call, is_gateway_owned_call, public_output_items,
 };
 use super::gateway_accumulator::{GatewayStreamAccumulator, StreamEvent, error_sse_chunk};
 use crate::events::EventFrame;
@@ -262,13 +262,21 @@ async fn execute_and_emit_ordered_output_calls(
     let first_gateway_index = output_items
         .iter()
         .position(|item| matches!(item, OutputItem::FunctionCall(call) if is_gateway_owned_call(call, registry)));
-    let first_gateway_run_end = first_gateway_index.map_or(0, |start| {
-        output_items[start..]
-            .iter()
-            .take_while(|item| matches!(item, OutputItem::FunctionCall(call) if is_gateway_owned_call(call, registry)))
-            .count()
-            .saturating_add(start)
-    });
+    let first_gateway_run_end = first_gateway_index
+        .filter(|start| {
+            !output_items[..*start]
+                .iter()
+                .any(|item| matches!(item, OutputItem::FunctionCall(call) if is_client_custom_call(call, registry)))
+        })
+        .map_or(0, |start| {
+            output_items[start..]
+                .iter()
+                .take_while(
+                    |item| matches!(item, OutputItem::FunctionCall(call) if is_gateway_owned_call(call, registry)),
+                )
+                .count()
+                .saturating_add(start)
+        });
     let first_gateway_run_len = first_gateway_run_end.saturating_sub(first_gateway_index.unwrap_or(0));
     emit_gateway_start_events(&event_plans[..first_gateway_run_len], stream_accumulator, stream_sender)?;