agenthub-python 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

agenthub/auto_client.py

@@ -54,10 +54,10 @@ class AutoLLMClient(LLMClient):
             from .claude4_6 import Claude4_6Client
 
             return Claude4_6Client(model=model, api_key=api_key, base_url=base_url)
-        elif "gpt-5.4" in client_type:  # e.g., gpt-5.4
-            from .gpt5_4 import GPT5_4Client
+        elif "gpt-5.4" in client_type or "gpt-5.5" in client_type:  # e.g., gpt-5.5
+            from .gpt5_5 import GPT5_5Client
 
-            return GPT5_4Client(model=model, api_key=api_key, base_url=base_url)
+            return GPT5_5Client(model=model, api_key=api_key, base_url=base_url)
         elif "glm-5" in client_type:
             from .glm5 import GLM5Client
 
@@ -73,7 +73,7 @@ class AutoLLMClient(LLMClient):
         else:
             raise ValueError(
                 f"{client_type} is not supported. "
-                "Supported client types: gemini-3, claude-4-6, gpt-5.4, glm-5, kimi-k2.5, qwen3."
+                "Supported client types: gemini-3, claude-4-6, gpt-5.4, gpt-5.5, glm-5, kimi-k2.5, qwen3."
             )
 
     def transform_uni_config_to_model_config(self, config: UniConfig) -> Any:
@@ -126,3 +126,7 @@ class AutoLLMClient(LLMClient):
     def get_history(self) -> list[UniMessage]:
         """Get history from the underlying client."""
         return self._client.get_history()
+
+    def set_history(self, history: list[UniMessage]) -> None:
+        """Set history in the underlying client."""
+        self._client.set_history(history)

agenthub/base_client.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import time
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator
 
@@ -84,6 +85,7 @@ class LLMClient(ABC):
         content_items: list[ContentItem] = []
         usage_metadata: UsageMetadata | None = None
         finish_reason: FinishReason | None = None
+        created_at: int | None = None
 
         for event in events:
             # Merge content_items from all events
@@ -119,12 +121,14 @@ class LLMClient(ABC):
 
             usage_metadata = event.get("usage_metadata")  # usage_metadata is taken from the last event
             finish_reason = event.get("finish_reason")  # finish_reason is taken from the last event
+            created_at = event.get("created_at")  # created_at is taken from the last event
 
         return {
             "role": "assistant",
             "content_items": content_items,
             "usage_metadata": usage_metadata,
             "finish_reason": finish_reason,
+            "created_at": created_at,
         }
 
     @abstractmethod
@@ -167,13 +171,29 @@ class LLMClient(ABC):
         Yields:
             Universal events from the streaming response
         """
+        # Stamp any messages that don't yet have a created_at timestamp
+        for msg in messages:
+            if "created_at" not in msg:
+                msg["created_at"] = int(time.time() * 1000)
+
         last_event: UniEvent | None = None
+        events = []
         async for event in self._streaming_response_internal(messages, config):
+            event["created_at"] = int(time.time() * 1000)
             last_event = event
+            events.append(event)
             yield event
 
         self._validate_last_event(last_event)
 
+        # Save history to file if trace_id is specified
+        if config.get("trace_id") and events:
+            from .integration.tracer import Tracer
+
+            assistant_message = self.concat_uni_events_to_uni_message(events)
+            tracer = Tracer()
+            tracer.save_history(self._model, messages + [assistant_message], config["trace_id"], config)
+
     async def streaming_response_stateful(
         self,
         message: UniMessage,
@@ -203,18 +223,12 @@ class LLMClient(ABC):
             yield event
 
         # Only update history after successful inference
+        # temp_messages[-1] is the user message, now stamped with created_at by streaming_response
         if events:
             assistant_message = self.concat_uni_events_to_uni_message(events)
-            self._history.append(message)
+            self._history.append(temp_messages[-1])
             self._history.append(assistant_message)
 
-        # Save history to file if trace_id is specified
-        if config.get("trace_id"):
-            from .integration.tracer import Tracer
-
-            tracer = Tracer()
-            tracer.save_history(self._model, self._history, config["trace_id"], config)
-
     @staticmethod
     def _validate_last_event(last_event: UniEvent | None) -> None:
         """Validate that the last event has usage_metadata and finish_reason.
@@ -244,3 +258,11 @@ class LLMClient(ABC):
     def get_history(self) -> list[UniMessage]:
         """Get the current message history."""
         return self._history.copy()
+
+    def set_history(self, history: list[UniMessage]) -> None:
+        """Replace the message history with a copy of the provided history.
+
+        Args:
+            history: List of universal message dictionaries to set as the new history
+        """
+        self._history = list(history)

agenthub/claude4_6/client.py

@@ -171,6 +171,15 @@ class Claude4_6Client(LLMClient):
         if config.get("tool_choice") is not None:
             claude_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
 
+        # Add cache_control if prompt caching is enabled
+        # TODO: wait for bedrock to support cache_control in config
+        if not self._use_bedrock:
+            prompt_caching = config.get("prompt_caching", PromptCaching.ENABLE)
+            if prompt_caching == PromptCaching.ENABLE:
+                claude_config["cache_control"] = {"type": "ephemeral"}
+            elif prompt_caching == PromptCaching.ENHANCE:
+                claude_config["cache_control"] = {"type": "ephemeral", "ttl": "1h"}
+
         return claude_config
 
     async def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[BetaMessageParam]:
@@ -334,18 +343,20 @@ class Claude4_6Client(LLMClient):
         # Use unified message conversion
         claude_messages = await self.transform_uni_message_to_model_input(messages)
 
-        # Add cache_control to last user message's last item if enabled
-        prompt_caching = config.get("prompt_caching", PromptCaching.ENABLE)
-        if prompt_caching != PromptCaching.DISABLE and claude_messages:
-            try:
-                last_user_message = next(filter(lambda x: x["role"] == "user", claude_messages[::-1]))
-                last_content_item = last_user_message["content"][-1]
-                last_content_item["cache_control"] = {
-                    "type": "ephemeral",
-                    "ttl": "1h" if prompt_caching == PromptCaching.ENHANCE else "5m",
-                }
-            except StopIteration:
-                pass
+        # Add cache_control to last user message's last item if using bedrock and enabled prompt caching
+        # TODO: remove after bedrock supports cache_control in config
+        if self._use_bedrock:
+            prompt_caching = config.get("prompt_caching", PromptCaching.ENABLE)
+            if prompt_caching != PromptCaching.DISABLE and claude_messages:
+                try:
+                    last_user_message = next(filter(lambda x: x["role"] == "user", claude_messages[::-1]))
+                    last_content_item = last_user_message["content"][-1]
+                    last_content_item["cache_control"] = {
+                        "type": "ephemeral",
+                        "ttl": "1h" if prompt_caching == PromptCaching.ENHANCE else "5m",
+                    }
+                except StopIteration:
+                    pass
 
         # Stream generate
         partial_tool_call = {}

agenthub/gemini3/client.py

@@ -147,6 +147,44 @@ class Gemini3Client(LLMClient):
         if config.get("prompt_caching") is not None and config["prompt_caching"] != PromptCaching.ENABLE:
             raise ValueError("prompt_caching must be ENABLE for Gemini 3.")
 
+        if config.get("image_config") is not None:
+            config_params["image_config"] = types.ImageConfig(**config["image_config"])
+
+        # tts config
+        if "tts" in self._model.lower():
+            config_params["response_modalities"] = ["AUDIO"]
+            tts_config = config.get("tts_config") or [{"voice": "Kore"}]
+            if len(tts_config) not in (1, 2):
+                raise ValueError("tts_config must contain 1 or 2 entries.")
+
+            if len(tts_config) == 1:
+                config_params["speech_config"] = types.SpeechConfig(
+                    voice_config=types.VoiceConfig(
+                        prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=tts_config[0]["voice"])
+                    )
+                )
+            else:
+                speaker_voice_configs = []
+                for speaker_config in tts_config:
+                    speaker = speaker_config.get("speaker")
+                    if not speaker:
+                        raise ValueError("speaker is required when tts_config has 2 entries.")
+
+                    speaker_voice_configs.append(
+                        types.SpeakerVoiceConfig(
+                            speaker=speaker,
+                            voice_config=types.VoiceConfig(
+                                prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=speaker_config["voice"])
+                            ),
+                        )
+                    )
+
+                config_params["speech_config"] = types.SpeechConfig(
+                    multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
+                        speaker_voice_configs=speaker_voice_configs
+                    )
+                )
+
         return types.GenerateContentConfig(**config_params) if config_params else None
 
     async def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[types.Content]:
@@ -170,10 +208,18 @@ class Gemini3Client(LLMClient):
                     image_url = item["image_url"]
                     image_data = await self._get_image_bytes_and_mime_type(image_url)
                     parts.append(types.Part.from_bytes(**image_data))
+                elif item["type"] == "inline_data":
+                    inline_data = types.Blob(data=item["data"], mime_type=item["mime_type"])
+                    parts.append(types.Part(inline_data=inline_data, thought_signature=item.get("signature")))
                 elif item["type"] == "thinking":
                     parts.append(
                         types.Part(text=item["thinking"], thought=True, thought_signature=item.get("signature"))
                     )
+                elif item["type"] == "inline_thinking":
+                    inline_data = types.Blob(data=item["data"], mime_type=item["mime_type"])
+                    parts.append(
+                        types.Part(inline_data=inline_data, thought=True, thought_signature=item.get("signature"))
+                    )
                 elif item["type"] == "tool_call":
                     function_call = types.FunctionCall(name=item["name"], args=item["arguments"])
                     parts.append(types.Part(function_call=function_call, thought_signature=item.get("signature")))
@@ -232,9 +278,28 @@ class Gemini3Client(LLMClient):
                             "signature": part.thought_signature,
                         }
                     )
-                elif part.text is not None and part.thought:
+                elif part.thought:
+                    if part.text is not None:
+                        content_items.append(
+                            {"type": "thinking", "thinking": part.text, "signature": part.thought_signature}
+                        )
+                    elif part.inline_data is not None:
+                        content_items.append(
+                            {
+                                "type": "inline_thinking",
+                                "data": part.inline_data.data,
+                                "mime_type": part.inline_data.mime_type,
+                                "signature": part.thought_signature,
+                            }
+                        )
+                elif part.inline_data is not None:
                     content_items.append(
-                        {"type": "thinking", "thinking": part.text, "signature": part.thought_signature}
+                        {
+                            "type": "inline_data",
+                            "data": part.inline_data.data,
+                            "mime_type": part.inline_data.mime_type,
+                            "signature": part.thought_signature,
+                        }
                     )
                 elif part.text is not None:
                     content_items.append({"type": "text", "text": part.text, "signature": part.thought_signature})
@@ -278,6 +343,15 @@ class Gemini3Client(LLMClient):
         # Use unified config conversion
         gemini_config = self.transform_uni_config_to_model_config(config)
 
+        # check if all items are text for tts model
+        if "tts" in self._model.lower():
+            invalid_item = next(
+                (item for message in messages for item in message["content_items"] if item["type"] != "text"),
+                None,
+            )
+            if invalid_item is not None:
+                raise ValueError(f"Gemini TTS only supports text input, got content item type={invalid_item['type']}.")
+
         # Use unified message conversion
         contents = await self.transform_uni_message_to_model_input(messages)
 

agenthub/glm5/client.py

@@ -206,9 +206,9 @@ class GLM5Client(LLMClient):
                     content_items.append(
                         {
                             "type": "partial_tool_call",
-                            "name": tool_call.function.name,
-                            "arguments": tool_call.function.arguments,
-                            "tool_call_id": tool_call.id,
+                            "name": tool_call.function.name or "",
+                            "arguments": tool_call.function.arguments or "",
+                            "tool_call_id": tool_call.id or "",
                         }
                     )
 

agenthub/{gpt5_4 → gpt5_5}/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .client import GPT5_4Client
+from .client import GPT5_5Client
 
 
-__all__ = ["GPT5_4Client"]
+__all__ = ["GPT5_5Client"]

agenthub/{gpt5_4 → gpt5_5}/client.py

@@ -24,6 +24,7 @@ from ..types import (
     EventType,
     FinishReason,
     PartialContentItem,
+    PromptCaching,
     ThinkingLevel,
     ToolChoice,
     UniConfig,
@@ -33,11 +34,11 @@ from ..types import (
 )
 
 
-class GPT5_4Client(LLMClient):
-    """GPT-5.4-specific LLM client implementation."""
+class GPT5_5Client(LLMClient):
+    """GPT-5.5-specific LLM client implementation."""
 
     def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
-        """Initialize GPT-5.4 client with model and API key."""
+        """Initialize GPT-5.5 client with model and API key."""
         self._model = model
         api_key = api_key or os.getenv("OPENAI_API_KEY")
         base_url = base_url or os.getenv("OPENAI_BASE_URL")
@@ -86,7 +87,7 @@ class GPT5_4Client(LLMClient):
             openai_config["max_output_tokens"] = config["max_tokens"]
 
         if config.get("temperature") is not None and config["temperature"] != 1.0:
-            raise ValueError("GPT-5.4 does not support setting temperature.")
+            raise ValueError("GPT-5.5 does not support setting temperature.")
 
         if config.get("thinking_level") is not None:
             openai_config["reasoning"] = {"effort": self._convert_thinking_level_to_effort(config["thinking_level"])}
@@ -99,6 +100,9 @@ class GPT5_4Client(LLMClient):
         if config.get("tool_choice") is not None:
             openai_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
 
+        if config.get("prompt_caching") is not None and config["prompt_caching"] != PromptCaching.ENABLE:
+            raise ValueError("prompt_caching must be ENABLE for GPT-5.5.")
+
         return openai_config
 
     def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> ResponseInputParam:
@@ -213,13 +217,14 @@ class GPT5_4Client(LLMClient):
                         "tool_call_id": model_output.item.call_id,
                     }
                 )
-            elif model_output.item.type == "reasoning":
-                event_type = "delta"
-                signature = {
-                    "id": model_output.item.id,
-                    "encrypted_content": model_output.item.encrypted_content,
-                }
-                content_items.append({"type": "thinking", "thinking": "", "signature": json.dumps(signature)})
+            # adding the following thinking item leads to 400 invalid request error, why?
+            # elif model_output.item.type == "reasoning":
+            #     event_type = "delta"
+            #     signature = {
+            #         "id": model_output.item.id,
+            #         "encrypted_content": model_output.item.encrypted_content,
+            #     }
+            #     content_items.append({"type": "thinking", "thinking": "", "signature": json.dumps(signature)})
             elif model_output.item.type == "message":
                 if hasattr(model_output.item, "phase"):
                     event_type = "delta"
@@ -311,7 +316,6 @@ class GPT5_4Client(LLMClient):
         # Stream generate
         partial_tool_call = {}
         stream = await self._client.responses.create(**openai_config, input=input_list, stream=True)
-
         async for event in stream:
             event = self.transform_model_output_to_uni_event(event)
             if event["event_type"] == "start":

agenthub/integration/playground.py

@@ -110,11 +110,13 @@ def create_chat_app() -> Flask:
                         class="px-3 py-2 border border-gray-300 rounded-md text-sm focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
                     />
                     <datalist id="modelList">
-                        <option value="gpt-5.2">GPT 5.2</option>
+                        <option value="gpt-5.5">GPT 5.5</option>
                         <option value="gemini-3-flash-preview">Gemini 3 Flash</option>
                         <option value="claude-sonnet-4-6">Claude Sonnet 4.6</option>
                         <option value="kimi-k2.5">Kimi K2.5</option>
                         <option value="glm-5">GLM 5</option>
+                        <option value="gemini-3.1-flash-image-preview">Gemini 3.1 Flash Image (Nano Banana 2)</option>
+                        <option value="gemini-3.1-flash-tts-preview">Gemini 3.1 Flash TTS</option>
                     </datalist>
                 </div>
                 <div class="flex flex-col">
@@ -191,6 +193,7 @@ def create_chat_app() -> Flask:
             let isStreaming = false;
             let sessionId = Math.random().toString(36).substring(7);
             let selectedImages = [];
+            let lastMessageTimestamp = null;
 
             function escapeHtml(text) {
                 const div = document.createElement('div');
@@ -198,6 +201,76 @@ def create_chat_app() -> Flask:
                 return div.innerHTML;
             }
 
+            function formatTimestamp(ms) {
+                if (!ms) return '';
+                const d = new Date(ms);
+                const pad = n => n.toString().padStart(2, '0');
+                return `${d.getFullYear()}-${pad(d.getMonth()+1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+            }
+
+            function pcmBase64ToWavDataUrl(pcmBase64, sampleRate = 24000, channels = 1, bitsPerSample = 16) {
+                const binary = atob(pcmBase64);
+                const pcmBytes = new Uint8Array(binary.length);
+                for (let i = 0; i < binary.length; i++) {
+                    pcmBytes[i] = binary.charCodeAt(i);
+                }
+
+                const header = new ArrayBuffer(44);
+                const view = new DataView(header);
+                const byteRate = sampleRate * channels * bitsPerSample / 8;
+                const blockAlign = channels * bitsPerSample / 8;
+
+                const writeString = (offset, value) => {
+                    for (let i = 0; i < value.length; i++) {
+                        view.setUint8(offset + i, value.charCodeAt(i));
+                    }
+                };
+
+                writeString(0, 'RIFF');
+                view.setUint32(4, 36 + pcmBytes.length, true);
+                writeString(8, 'WAVE');
+                writeString(12, 'fmt ');
+                view.setUint32(16, 16, true);
+                view.setUint16(20, 1, true);
+                view.setUint16(22, channels, true);
+                view.setUint32(24, sampleRate, true);
+                view.setUint32(28, byteRate, true);
+                view.setUint16(32, blockAlign, true);
+                view.setUint16(34, bitsPerSample, true);
+                writeString(36, 'data');
+                view.setUint32(40, pcmBytes.length, true);
+
+                const wavBytes = new Uint8Array(44 + pcmBytes.length);
+                wavBytes.set(new Uint8Array(header), 0);
+                wavBytes.set(pcmBytes, 44);
+
+                let wavBinary = '';
+                const chunkSize = 0x8000;
+                for (let i = 0; i < wavBytes.length; i += chunkSize) {
+                    wavBinary += String.fromCharCode(...wavBytes.subarray(i, i + chunkSize));
+                }
+                return `data:audio/wav;base64,${btoa(wavBinary)}`;
+            }
+
+            function renderInlineData(item) {
+                const mimeType = (item.mime_type || '').toLowerCase();
+                if (mimeType.startsWith('image/')) {
+                    return `<div class="mb-3"><img src="data:${mimeType || 'image/png'};base64,${item.data}" class="max-w-xs rounded border border-gray-300"></div>`;
+                }
+
+                const audioMimeTypes = ['audio/wav', 'audio/x-wav', 'audio/mpeg', 'audio/mp3', 'audio/ogg', 'audio/webm', 'audio/flac', 'audio/aac', 'audio/mp4'];
+                const isAudio = !mimeType || mimeType === 'application/octet-stream' || mimeType.startsWith('audio/');
+                if (!isAudio) {
+                    return `<div class="mb-3 rounded border border-gray-300 bg-gray-50 px-3 py-2 text-xs text-gray-600">Inline data: ${escapeHtml(item.mime_type || 'application/octet-stream')}</div>`;
+                }
+
+                const playableMimeType = audioMimeTypes.includes(mimeType);
+                const audioSrc = playableMimeType
+                    ? `data:${mimeType || 'application/octet-stream'};base64,${item.data}`
+                    : pcmBase64ToWavDataUrl(item.data);
+                return `<div class="mb-3"><audio controls preload="metadata" class="max-w-xs"><source src="${audioSrc}" type="${playableMimeType ? mimeType : 'audio/wav'}"></audio></div>`;
+            }
+
             function handleImageSelect(event) {
                 const files = event.target.files;
                 if (!files || files.length === 0) return;
@@ -302,7 +375,7 @@ def create_chat_app() -> Flask:
                 return config;
             }
 
-            function addMessageCard(role, content, metadata = null, images = []) {
+            function addMessageCard(role, content, metadata = null, images = [], timestamp = null, tookMs = null) {
                 const container = document.getElementById('messagesContainer');
 
                 if (container.children.length === 1 && container.children[0].className.includes('text-center')) {
@@ -316,6 +389,10 @@ def create_chat_app() -> Flask:
                 let html = `
                     <div class="flex justify-between items-center mb-3">
                         <span class="font-semibold text-sm uppercase ${isUser ? 'text-blue-600' : 'text-green-600'}">${role}</span>
+                        <div class="flex items-center gap-2">
+                            <span class="msg-took text-xs text-gray-400">${tookMs !== null ? 'Took ' + tookMs + ' ms' : ''}</span>
+                            <span class="text-xs text-gray-400 msg-timestamp">${timestamp ? formatTimestamp(timestamp) : ''}</span>
+                        </div>
                     </div>
                 `;
 
@@ -350,6 +427,7 @@ def create_chat_app() -> Flask:
             async function sendMessage() {
                 const input = document.getElementById('messageInput');
                 const sendButton = document.getElementById('sendButton');
+                const container = document.getElementById('messagesContainer');
                 const message = input.value.trim();
 
                 if ((!message && selectedImages.length === 0) || isStreaming) return;
@@ -363,7 +441,9 @@ def create_chat_app() -> Flask:
                 selectedImages = [];
                 updateImagePreview();
 
-                addMessageCard('user', message, null, currentImages);
+                const userSendTime = Date.now();
+                const timeSinceLastResponse = lastMessageTimestamp !== null ? userSendTime - lastMessageTimestamp : null;
+                addMessageCard('user', message, null, currentImages, userSendTime, timeSinceLastResponse);
 
                 const assistantCard = addMessageCard('assistant', '');
                 const contentDiv = assistantCard.querySelector('.message-content');
@@ -402,14 +482,19 @@ def create_chat_app() -> Flask:
                     let fullToolName = '';
                     let fullToolArgs = '';
                     let metadata = null;
+                    let lastCreatedAt = null;
+                    let buffer = '';
 
                     while (true) {
                         const { done, value } = await reader.read();
                         if (done) break;
 
                         const chunk = decoder.decode(value);
-                        const lines = chunk.split('\\n');
+                        buffer += chunk;
+                        if (!buffer.endsWith('\\n\\n')) continue;
 
+                        const lines = buffer.split('\\n');
+                        buffer = '';
                         for (const line of lines) {
                             if (line.startsWith('data: ')) {
                                 const data = line.slice(6);
@@ -439,6 +524,9 @@ def create_chat_app() -> Flask:
                                                 contentDiv.insertBefore(thinkingContainer, textContainer || contentDiv.firstChild);
                                             }
                                             thinkingContainer.textContent = `💭 ${fullThinking}`;
+                                        } else if (item.type === 'inline_thinking') {
+                                            // Ignore thinking inline data
+                                            continue;
                                         } else if (item.type === 'partial_tool_call') {
                                             fullToolName += item.name || '';
                                             fullToolArgs += item.arguments || '';
@@ -454,9 +542,16 @@ def create_chat_app() -> Flask:
                                             toolResultDiv.className = 'bg-green-50 p-3 rounded-md border-l-4 border-green-500 mb-2';
                                             toolResultDiv.innerHTML = `<strong class="text-sm">✅ Tool Result:</strong><br><div class="mt-1 text-xs whitespace-pre-wrap">${escapeHtml(item.text)}</div>`;
                                             contentDiv.appendChild(toolResultDiv);
+                                        } else if (item.type === 'inline_data') {
+                                            const inlineDataDiv = document.createElement('div');
+                                            inlineDataDiv.innerHTML = renderInlineData(item);
+                                            if (inlineDataDiv.firstChild) {
+                                                contentDiv.appendChild(inlineDataDiv.firstChild);
+                                            }
                                         }
                                     }
 
+                                    container.scrollTop = container.scrollHeight;
                                     if (event.usage_metadata) {
                                         const usage = event.usage_metadata;
                                         const inputTokens = (usage.cached_tokens || 0) + (usage.prompt_tokens || 0);
@@ -474,6 +569,9 @@ def create_chat_app() -> Flask:
                                         metadata = metadata || {};
                                         metadata.finish_reason = event.finish_reason;
                                     }
+                                    if (event.created_at) {
+                                        lastCreatedAt = event.created_at;
+                                    }
                                 } catch (e) {
                                     console.error('Error parsing event:', e);
                                 }
@@ -481,6 +579,21 @@ def create_chat_app() -> Flask:
                         }
                     }
 
+                    if (lastCreatedAt) {
+                        const timestampEl = assistantCard.querySelector('.msg-timestamp');
+                        if (timestampEl) {
+                            timestampEl.textContent = formatTimestamp(lastCreatedAt);
+                        }
+                    }
+
+                    const endTime = Date.now();
+                    const responseTimeMs = endTime - userSendTime;
+                    lastMessageTimestamp = endTime;
+                    const tookEl = assistantCard.querySelector('.msg-took');
+                    if (tookEl) {
+                        tookEl.textContent = `Took ${responseTimeMs} ms`;
+                    }
+
                     if (metadata) {
                         let metadataHtml = '<div class="flex justify-end gap-3 mt-3 pt-3 border-t border-gray-200 text-xs text-gray-500">';
                         const parts = [];
@@ -500,6 +613,7 @@ def create_chat_app() -> Flask:
                 } catch (error) {
                     contentDiv.textContent = `Error: ${error.message}`;
                     console.error('Error:', error);
+                    lastMessageTimestamp = Date.now();
                 }
 
                 isStreaming = false;
@@ -518,6 +632,7 @@ def create_chat_app() -> Flask:
                         })
                     }).then(() => {
                         sessionId = Math.random().toString(36).substring(7);
+                        lastMessageTimestamp = null;
                         const container = document.getElementById('messagesContainer');
                         container.innerHTML = `
                             <div class="text-center text-gray-500 py-10">
@@ -543,6 +658,7 @@ def create_chat_app() -> Flask:
                 this.style.height = 'auto';
                 this.style.height = Math.min(this.scrollHeight, 200) + 'px';
             });
+
         </script>
     </body>
     </html>
@@ -569,7 +685,7 @@ def create_chat_app() -> Flask:
             try:
                 # Get or create client for this session
                 if session_id not in _session_clients:
-                    model = config.get("model") or "gpt-5.2"
+                    model = config.get("model") or "gpt-5.5"
                     _session_clients[session_id] = AutoLLMClient(model=model)
 
                 client = _session_clients[session_id]