Upload folder using huggingface_hub

.gitattributes

@@ -34,3 +34,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 tokenizer.json filter=lfs diff=lfs merge=lfs -text
+image/4356.jpg filter=lfs diff=lfs merge=lfs -text
+image/CHEM-059.png filter=lfs diff=lfs merge=lfs -text
+image/CHEM-059_1939.png filter=lfs diff=lfs merge=lfs -text
+image/HRbench_4k_231.jpg filter=lfs diff=lfs merge=lfs -text
+image/HRbench_4k_231_01c150b9.jpg filter=lfs diff=lfs merge=lfs -text
+image/HRbench_4k_231_5e355368.jpg filter=lfs diff=lfs merge=lfs -text
+image/P2504_0017.png filter=lfs diff=lfs merge=lfs -text
+image/P2504_0017_6934c19b.png filter=lfs diff=lfs merge=lfs -text
+image/s1-vl-32b-benchmark.png filter=lfs diff=lfs merge=lfs -text
+image/s1-vl-32b-twi.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,184 @@
----
-license: apache-2.0
----
+# S1-VL-32B: Scientific Multimodal Reasoning Model
+
+[中文版](./README_zh.md) | [English](./README.md)
+
+## 🔬 Introduction
+
+**S1-VL-32B** is a multimodal large language model for scientific domains, developed by the ScienceOne team at the Chinese Academy of Sciences. It natively supports two reasoning paradigms — **Multimodal Reasoning** and **Thinking with Images** — and achieves state-of-the-art performance across multiple mainstream scientific multimodal evaluation benchmarks.
+
+- **Multimodal Reasoning Mode**: Chain-of-thought-based multimodal scientific reasoning, designed for the analysis and solving of complex, multi-step problems.
+- **Thinking with Images Mode**: Enables the model to actively invoke code tools during the reasoning process to perform image operations — including cropping, zooming, image enhancement, bounding box annotation, and keypoint marking — before generating responses.
+
+We have established a **cross-disciplinary data processing pipeline** that conducts multi-dimensional utility evaluation and filtering of visual reasoning trajectories to ensure the quality of training data. A **multi-stage post-training procedure** is employed to progressively unlock the scientific reasoning capabilities of S1-VL-32B:
+
+- **Stage 1**: Large-scale multimodal instruction data spanning multiple disciplines — including **mathematics, physics, chemistry, astronomy, earth sciences, and biology** — is used for mixed training to enhance the model's scientific visual understanding and logical reasoning abilities, laying a solid foundation for academic figure Q&A, medical image analysis, chemical structure recognition, and related tasks.
+- **Stage 2**: The **Thinking with Images** reasoning paradigm is introduced. Through high-quality **scientific reasoning data annealing**, the model acquires the ability to perform **image operations via code** during inference. This approach yields particularly outstanding performance in scenarios requiring fine-grained image analysis, with notable strengths in interpreting dense scientific charts, high-resolution remote sensing imagery, microscopic images, and complex visual scenes such as astronomical observation data.
+
+## 📂 Model Weights
+
+| Model | Parameters | HuggingFace | ModelScope |
+|-------|-----------|-------------|------------|
+| S1-VL-32B | 32B | 🤗 [Download](https://huggingface.co/ScienceOne-AI/S1-VL-32B) | 🤖 [Download](https://modelscope.cn/models/ScienceOne-AI/S1-VL-32B) |
+
+## 🏆 Evaluation Results
+
+The evaluation covers **2 dimensions** and **13 benchmarks**. The **Scientific Multimodal Reasoning** dimension includes MMMU, SFE, MathVision, Physics, ScienceOlympiad, VRSBench-MINI, GMAI-MMBench, and Galaxy-10-DECaLS, spanning mathematics, physics, medicine, remote sensing, astronomy, and other professional fields. The **Image Manipulation Reasoning** dimension includes HRBench-4K, HRBench-8K, MME-RealWorld-CN, MME-RealWorld-Lite, and V*, focusing on high-resolution image understanding and real-world visual reasoning.
+
+<div align="center">
+<img src="./image/s1-vl-32b-benchmark.png"/>
+</div>
+
+S1-VL-32B demonstrates outstanding overall competitiveness across the aforementioned evaluations. In **scientific multimodal reasoning** tasks, the model achieves significant advantages on multiple authoritative benchmarks — including MMMU, MathVision, and VRSBench-MINI — surpassing its base model Qwen3-VL-32B in overall performance, while remaining highly competitive against open-source models with substantially larger parameter scales (e.g., Qwen3-VL-235B, Intern-S1) as well as closed-source flagship models (e.g., Gemini 2.5 Pro, GPT-5). In **image operation reasoning** tasks, S1-VL-32B ranks **first across all five benchmark evaluations**, comprehensively outperforming models of comparable and larger scales, while also surpassing dedicated "Thinking with Images" models such as Thyme-VL and Skywork-R1V4. These results fully validate its ability to achieve efficient, high-quality multimodal reasoning at the 32B parameter scale.
+
+## 🧠 Case Study
+
+The following presents reasoning examples of S1-VL-32B operating in **Thinking with Images** mode. When processing a low-resolution cervical CT image, S1-VL-32B proactively invokes code tools during its reasoning process to perform **cropping and magnification** on the region of interest. By obtaining a clearer local image, the model then combines the enhanced visual information with its internal knowledge to complete the reasoning.
+
+<div align="center">
+<img src="./image/s1-vl-32b-twi.png"/>
+</div>
+
+📁 More cases are available in [CASES.md](./CASES.md).
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+
+```bash
+# Requires vLLM >= 0.11.0
+pip install -U vllm
+pip install qwen-vl-utils==0.0.14
+```
+
+### 2. Start the vLLM Service
+
+```bash
+vllm serve ScienceOne-AI/S1-VL-32B \
+    --tensor-parallel-size 4 \
+    --max-model-len 32768 \
+    --limit-mm-per-prompt image=15 \
+    --reasoning-parser deepseek_r1 \
+    --enable-prefix-caching \
+    --gpu-memory-utilization 0.95 \
+    --port 9200
+```
+
+### 3. Multimodal Reasoning Mode
+
+```python
+from openai import OpenAI
+import base64
+
+client = OpenAI(api_key="EMPTY", base_url="http://localhost:9200/v1")
+
+with open("path/to/your/image.png", "rb") as f:
+    image_data = base64.b64encode(f.read()).decode("utf-8")
+
+response = client.chat.completions.create(
+    model="ScienceOne-AI/S1-VL-32B",
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}},
+                {"type": "text", "text": "Please describe the physical phenomenon shown in the image and derive the relevant equations."},
+            ],
+        }
+    ],
+    temperature=0.6,
+    top_p=0.95,
+    max_tokens=16384,
+)
+
+# The reasoning process is in the reasoning_content field
+print("Thinking process:\n", response.choices[0].message.reasoning_content)
+print("\nFinal answer:\n", response.choices[0].message.content)
+```
+
+### 4. Thinking with Images Mode
+
+Thinking with Images mode requires deploying a **code sandbox** to support the model invoking code tools during reasoning for image operations (cropping, zooming, enhancement, annotation, etc.).
+
+#### Step 1: Deploy the Code Sandbox
+
+We recommend deploying the AIO Sandbox with Docker:
+
+```bash
+git clone https://github.com/agent-infra/sandbox
+cd sandbox
+# Mount the host image directory into the container
+docker run -d \
+    --name twi-sandbox \
+    -p 18081:18081 \
+    -v /data/images:/mnt/data/images \   # host path → sandbox path
+    sandbox:latest
+```
+The mount path must match the path configuration in the FastAPI service.
+
+#### Step 2: Start the Thinking with Images FastAPI Service
+
+Download [twi_server.py](twi_server.py) and update the path configuration at the top of the file:
+
+```python
+CHAT_API        = "http://localhost:9200/v1/chat/completions"  # vLLM address
+JUPYTER_API     = "http://localhost:18081/v1/jupyter"          # Sandbox address
+HOST_IMG_DIR    = "/data/images"     # ← Host image directory (must match docker -v mount)
+```
+
+Start the service:
+
+```bash
+pip install fastapi uvicorn httpx pillow
+python twi_server.py   # Listens on port 10044
+```
+
+#### Step 3: Call the Thinking with Images Endpoint
+
+```python
+import httpx
+import base64
+
+with open("path/to/your/image.png", "rb") as f:
+    image_b64 = base64.b64encode(f.read()).decode("utf-8")
+
+messages = [
+    {"type": "text", "text": "Please carefully analyze this scientific image."},
+    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}},
+]
+
+response = httpx.post(
+    "http://localhost:10044/process",
+    json={
+        "messages": messages,
+        "image_path_list": ["/data/images/your_image.png"],  # Absolute host path
+    },
+    timeout=300,
+)
+
+result = response.json()
+
+# The final answer is the last message with role="assistant"
+final = [m for m in result["messages"] if m["role"] == "assistant"][-1]
+print(final["content"])
+```
+
+## 📄 Citation
+
+If you use S1-VL-32B in your research, please cite (the corresponding paper is coming soon):
+
+```latex
+@misc{s1vl2026,
+  title        = {S1-VL-32B: Scientific Multimodal Reasoning Model},
+  author       = {ScienceOne Team},
+  year         = {2026},
+  howpublished = {\url{https://huggingface.co/ScienceOne-AI/S1-VL-32B}}
+}
+```
+
+## 📜 License
+
+This project is released under the Apache 2.0 License.
+
+## 🙏 Acknowledgements
+
+We thank the open-source communities and pioneering works of [Qwen3-VL](https://modelscope.cn/collections/Qwen3-VL-5c7a94c8cb144b) and [AIO Sandbox](https://github.com/agent-infra/sandbox) for laying the foundation for the scientific multimodal reasoning research behind S1-VL-32B.

README_zh.md

@@ -0,0 +1,177 @@
+# S1-VL-32B：科学多模态推理模型
+
+[中文版](./README_zh.md) ｜ [English](./README.md)
+
+## 🔬 模型简介
+**S1-VL-32B** 是由中国科学院 “磐石 · 科学基础大模型” ScienceOne 团队研发的面向科学领域的多模态大语言模型，原生支持 **Multimodal Reasoning（多模态推理）** 与 **Thinking with Images（图像思考）** 两种推理范式，在多项主流科学多模态评测基准上达到当前最优水平。
+- **Multimodal Reasoning 模式**：基于思维链的多模态科学推理，适用于复杂多步问题的分析与求解。
+- **Thinking with Images 模式**：允许模型在推理过程中在思考过程中主动调用代码工具进行图像操作（包括裁剪、放缩、图像增强、画框标注、描点标记等）再生成回答。
+
+我们建立**跨学科体系的数据处理管道**对视觉推理轨迹进行多维度效用评估与筛选，确保训练推理轨迹的质量；并采用多阶段后训练流程逐步解锁S1-VL-32B 模型的科学推理能力：
+- 首先，基于涵盖**数理化天地生**等多学科的大规模多模态指令数据进行混合训练，提升模型科学视觉理解和逻辑推理能力，使模型在学术图像问答、医学影像分析、化学结构识别等方面奠定坚实基础；
+- 然后，引入 **Thinking with Images** 推理范式，通过高质量**科学推理数据退火**，使模型具备在推理过程中通过代码进行**图像操作**的能力，在需要精细化图像分析的场景中表现尤为突出，尤其擅长解读密集科学图表、高分辨率遥感图像、显微图像及天文观测数据等复杂视觉场景。
+
+
+## 📂 模型权重
+
+| 模型名称 | 参数量 | HuggingFace | ModelScope |
+|--------|------|-------------|------------|
+| S1-VL-32B | 32B | 🤗 [下载](https://huggingface.co/ScienceOne-AI/S1-VL-32B) | 🤖 [下载](https://modelscope.cn/models/ScienceOne-AI/S1-VL-32B) |
+
+
+## 🏆 评测结果
+
+本次评测共涵盖 **2大维度**、**13个基准**。**科学多模态推理**方向涵盖 MMMU、SFE、MathVision、Physics、ScienceOlympiad、VRSBench-MINI、GMAI-MMBench 和 Galaxy-10-DECaLS，覆盖数学、物理、医学、遥感、天文等多个专业领域；**图像操作推理**方向则包含 HRBench-4K、HRBench-8K、MME-RealWorld-CN、MME-RealWorld-Lite 和 V*，重点考察模型在高分辨率图像理解与真实场景视觉推理中的表现。
+
+<div align="center">
+<img src="./image/s1-vl-32b-benchmark.png"/>
+</div>
+
+S1-VL-32B 在上述评测中展现出突出的综合竞争力。在**科学多模态推理**任务中，模型在 MMMU、MathVision、VRSBench-MINI 等多个权威基准上优势显著，整体性能超越基座模型 Qwen3-VL-32B，并与更大参数规模的开源模型（如 Qwen3-VL-235B、Intern-S1）以及闭源旗舰模型（如 Gemini 2.5 Pro、GPT-5）保持相当的竞争力；在**图像操作推理**任务中，S1-VL-32B 在全部五项基准评测中均位列第一，全面领先于同规模及更大规模模型，同时优于 Thyme-VL、Skywork-R1V4 等 “Thinking with Images” 专有模型，充分验证了其在 32B 参数规模下实现高效且高质量多模态推理的能力。
+
+## 🧠 案例展示
+
+以下展示 S1-VL-32B 在 **Thinking with Images** 模式下的推理案例。S1-VL-32B在处理一张低分辨率的颈部CT图像的思考过程中主动调用代码工具，对目标区域进行**裁剪与放大**，获取更清晰的局部图像后，再结合模型内部知识完成推理。
+
+<div align="center">
+<img src="./image/s1-vl-32b-twi.png"/>
+</div>
+
+📁 更多案例详见 [CASES.md](./CASES.md) 文件。
+
+## 🚀 快速开始
+### 1. 安装依赖
+
+```bash
+# 需要 vLLM >= 0.11.0
+pip install -U vllm
+pip install qwen-vl-utils==0.0.14
+```
+
+### 2. 启动 vLLM 服务
+```bash
+vllm serve ScienceOne-AI/S1-VL-32B \
+    --tensor-parallel-size 4 \
+    --max-model-len 32768 \
+    --limit-mm-per-prompt image=15 \
+    --reasoning-parser deepseek_r1 \
+    --enable-prefix-caching \
+    --gpu-memory-utilization 0.95 \
+    --port 9200
+```
+
+### 3. Multimodal Reasoning 模式
+```python
+from openai import OpenAI
+import base64
+
+client = OpenAI(api_key="EMPTY", base_url="http://localhost:9200/v1")
+
+with open("path/to/your/image.png", "rb") as f:
+    image_data = base64.b64encode(f.read()).decode("utf-8")
+
+response = client.chat.completions.create(
+    model="ScienceOne-AI/S1-VL-32B",
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}},
+                {"type": "text", "text": "请描述图中所示的物理现象并推导相关方程。"},
+            ],
+        }
+    ],
+    temperature=0.2,
+    max_tokens=16384,
+)
+
+# 推理过程在 reasoning_content 字段中
+print("思考过程：\n", response.choices[0].message.reasoning_content)
+print("\n最终答案：\n", response.choices[0].message.content)
+```
+
+### 4. Thinking with Images 模式
+
+Thinking with Images 模式需要部署**代码沙箱**，以支持模型在推理过程中调用代码工具实现图像操作（裁剪、放缩、增强、标注等）。
+
+#### Step 1：部署代码沙箱
+
+推荐使用 Docker 部署 AIO Sandbox：
+
+```bash
+git clone https://github.com/agent-infra/sandbox
+cd sandbox
+# 将宿主机图片目录挂载到容器内
+docker run -d \
+    --name twi-sandbox \
+    -p 18081:18081 \
+    -v /data/images:/mnt/data/images \   # 宿主机路径 → 沙箱内路径
+    sandbox:latest
+```
+挂载路径需与 FastAPI 服务中的路径配置保持一致。
+
+#### Step 2：启动 Thinking with Images FastAPI 服务
+
+下载 [twi_server.py](twi_server.py)，修改文件顶部的路径配置：
+
+```python
+CHAT_API        = "http://localhost:9200/v1/chat/completions"  # vLLM 地址
+JUPYTER_API     = "http://localhost:18081/v1/jupyter"          # 沙箱地址
+HOST_IMG_DIR    = "/data/images"     # ← 宿主机图片目录（需与 docker -v 挂载一致）
+```
+
+启动服务：
+
+```bash
+pip install fastapi uvicorn httpx pillow
+python twi_server.py   # 监听 10044 端口
+```
+
+#### Step 3：调用 Thinking with Images 接口
+
+```python
+import httpx
+import base64
+
+with open("path/to/your/image.png", "rb") as f:
+    image_b64 = base64.b64encode(f.read()).decode("utf-8")
+
+messages = [
+    {"type": "text", "text": "请仔细分析这张科学图像。"},
+    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}},
+]
+
+response = httpx.post(
+    "http://localhost:10044/process",
+    json={
+        "messages": messages,
+        "image_path_list": ["/data/images/your_image.png"],  # 宿主机绝对路径
+    },
+    timeout=300,
+)
+
+result = response.json()
+
+# 最终答案为最后一条 role="assistant" 的消息
+final = [m for m in result["messages"] if m["role"] == "assistant"][-1]
+print(final["content"])
+```
+
+## 📄 引用
+
+如果您在研究中使用了 S1-VL-32B，欢迎引用（相关论文即将发布，敬请期待）：
+```latex
+@misc{s1vl2026,
+  title        = {S1-VL-32B: Scientific Multimodal Reasoning Model},
+  author       = {ScienceOne Team},
+  year         = {2026},
+  howpublished = {\url{https://huggingface.co/ScienceOne-AI/S1-VL-32B}}
+}
+```
+
+
+## 📜 开源协议
+本项目基于 Apache 2.0 LICENSE 开源发布。
+
+## 🙏 致谢
+感谢 [Qwen3-VL](https://modelscope.cn/collections/Qwen3-VL-5c7a94c8cb144b)、[AIO Sandbox](https://github.com/agent-infra/sandbox) 等开源社区和先驱工作为 S1-VL-32B 科学多模态推理的研究工作奠定的基础。

twi_server.py

@@ -0,0 +1,237 @@
+import json
+import base64
+from pathlib import Path
+
+import httpx
+from PIL import Image
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Any
+
+app = FastAPI(title="Thinking with Images API")
+
+# ── Configuration ──
+MODEL_NAME = "model_name"
+CHAT_API   = "http://localhost:9200/v1/chat/completions"
+JUPYTER_API = "http://localhost:18081/v1/jupyter"
+
+# Sandbox internal paths  <->  host machine real paths (docker volume mapping)
+SANDBOX_IMG_DIR = "/mnt/data"
+HOST_IMG_DIR    = "/data"           # ← update to match actual mount path
+SANDBOX_TMP_DIR = "/mnt/data/images/temp"  # fixed path — do not change
+HOST_TMP_DIR    = "/data/thinking_with_images/temp"
+
+SYSTEM_PROMPT = '''
+You are a helpful assistant.
+
+# Tools
+You may call one or more functions to assist with the user query.
+You are provided with function signatures within <tools></tools> XML tags:
+
+<tools>
+{"type": "function", "function": {"name": "python", "description": "Use this tool to execute Python code in your chain of thought.\n\nWhen you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 60.0 seconds. The drive at '/mnt/data/images/temp' can be used to save the temporary image files. Internet access for this session is disabled. Do not make external web requests or API calls as they will fail.\n\nReasoning & Image Manipulation & Drawing Auxiliary Graphics (Optional but Encouraged):\n- You have the capability to write executable Python code to perform image manipulations (e.g., cropping to a Region of Interest (ROI), resizing, rotation, adjusting contrast) or perform calculation for better reasoning.\n- You have the capability to write Python code to add auxiliary graphics (such as segments, circles, rectangles, labels, etc.) to the image, to help illustrate your reasoning process.\n- The code will be executed in a secure sandbox, and its output will be provided back to you for further analysis.\n- At the end of the code, print the path of the processed image (processed_path) or the relevant result for further processing within the sandbox environment.", "parameters": {"type": "object", "properties": {"code": {"type": "string", "description": "The Python code to execute"}}}, "required": ["code"]}}
+</tools>
+
+For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
+<tool_call>
+{"name": <function-name>, "arguments": <args-json-object>}
+</tool_call>
+'''
+
+MAX_TURNS = 8
+
+class RequestModel(BaseModel):
+    messages: List[Dict[str, Any]]
+    image_path_list: List[str]
+
+
+# ── Utility Functions ──
+
+def get_img_size(path: str) -> tuple[int, int]:
+    with Image.open(path) as img:
+        return img.size  # (width, height)
+
+
+def encode_image(path: str) -> str:
+    return base64.b64encode(Path(path).read_bytes()).decode()
+
+
+def to_sandbox_path(host_path: str) -> str:
+    """Convert a host machine path to the corresponding sandbox path."""
+    return host_path.replace(HOST_IMG_DIR, SANDBOX_IMG_DIR)
+
+
+def to_host_path(sandbox_path: str) -> str:
+    """Convert a sandbox path to the corresponding host machine path."""
+    return sandbox_path.replace(SANDBOX_TMP_DIR + "/", HOST_TMP_DIR + "/")
+
+
+def build_user_content(
+    messages: List[Dict[str, Any]],
+    image_path_list: List[str],
+) -> List[Dict[str, Any]]:
+    """Inject image metadata (path, dimensions) after each image_url item in the message content."""
+    content, k = [], 0
+    for item in messages:
+        content.append(item)
+        if item["type"] == "image_url":
+            if k >= len(image_path_list):
+                raise ValueError(
+                    f"image_path_list too short: need image #{k+1} but only {len(image_path_list)} provided"
+                )
+            w, h = get_img_size(image_path_list[k])
+            sandbox_path = to_sandbox_path(image_path_list[k])
+            content.append({
+                "type": "text",
+                "text": f"\nimage path: {sandbox_path}\nimage width: {w}\nimage height: {h}\n\n",
+            })
+            k += 1
+    return content
+
+
+def build_initial_payload(user_content: List[Dict[str, Any]]) -> Dict[str, Any]:
+    return {
+        "model": MODEL_NAME,
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user",   "content": user_content},
+        ],
+        "skip_special_tokens": False,
+    }
+
+
+def messages_to_text(payload_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Flatten multimodal content in the final messages to plain text (for response/storage)."""
+    result = []
+    for msg in payload_messages:
+        if msg["role"] == "user" and isinstance(msg["content"], list):
+            text = ""
+            for item in msg["content"]:
+                if item["type"] == "image_url":
+                    text += "<image>"
+                elif item["type"] == "text":
+                    text += item["text"]
+            result.append({**msg, "content": text})
+        else:
+            result.append(msg)
+    return result
+
+
+# ── Core Logic ──
+
+async def process_request(
+    messages: List[Dict[str, Any]],
+    image_path_list: List[str],
+) -> Dict[str, Any]:
+
+    user_content = build_user_content(messages, image_path_list)
+    payload = build_initial_payload(user_content)
+
+    async with httpx.AsyncClient(timeout=300.0) as client:
+
+        # 1. Create Jupyter session
+        try:
+            r = await client.post(
+                f"{JUPYTER_API}/sessions/create",
+                json={"kernel_name": "python3.10"},
+            )
+            r.raise_for_status()
+            session_id = r.json()["data"]["session_id"]
+        except Exception as e:
+            raise HTTPException(500, f"Failed to create Jupyter session: {e}")
+
+        try:
+            for turn in range(1, MAX_TURNS + 1):
+
+                # 2. Call the model
+                try:
+                    r = await client.post(
+                        CHAT_API,
+                        json=payload,
+                        timeout=120.0,
+                    )
+                    r.raise_for_status()
+                    resp = r.json()
+                except Exception as e:
+                    raise HTTPException(500, f"Model API request failed (turn={turn}): {e}")
+
+                if "choices" not in resp:
+                    raise HTTPException(500, f"Unexpected model response: {resp}")
+
+                choice  = resp["choices"][0]["message"]
+                thinking = (choice.get("reasoning") or "").strip()
+                answer   = choice["content"].strip()
+                assistant_msg = f"<think>\n{thinking}\n</think>\n\n{answer}"
+
+                # 3. No tool call — conversation complete
+                if "<tool_call>" not in answer:
+                    payload["messages"].append({"role": "assistant", "content": assistant_msg})
+                    break
+
+                # 4. Parse and execute the tool call
+                try:
+                    raw = answer.split("<tool_call>")[1].split("</tool_call>")[0]
+                    code = json.loads(raw)["arguments"]["code"]
+                except Exception as e:
+                    raise HTTPException(500, f"Failed to parse tool_call: {e}")
+
+                try:
+                    r = await client.post(
+                        f"{JUPYTER_API}/execute",
+                        json={"code": code, "timeout": 30,
+                              "kernel_name": "python3.10", "session_id": session_id},
+                        timeout=60.0,
+                    )
+                    r.raise_for_status()
+                    exec_res = r.json()
+                except Exception as e:
+                    raise HTTPException(500, f"Code execution failed: {e}")
+
+                # Skip this turn if execution failed
+                if not exec_res["success"]:
+                    continue
+
+                sandbox_img_path = exec_res["data"]["outputs"][0]["text"].strip()
+                host_img_path    = to_host_path(sandbox_img_path)
+                image_path_list.append(host_img_path)
+                img_b64 = f"data:image/jpeg;base64,{encode_image(host_img_path)}"
+
+                payload["messages"].append({"role": "assistant", "content": assistant_msg})
+                payload["messages"].append({
+                    "role": "user",
+                    "content": [
+                        {"type": "text",      "text": "<tool_response>\n"},
+                        {"type": "image_url", "image_url": {"url": img_b64}},
+                        {"type": "text",      "text": f"\n{sandbox_img_path}\n</tool_response>"},
+                    ],
+                })
+
+        finally:
+            # 5. Clean up the Jupyter session
+            try:
+                await client.delete(f"{JUPYTER_API}/sessions/{session_id}")
+            except Exception as e:
+                print(f"[WARN] Failed to delete Jupyter session: {e}")
+
+    payload["messages"]      = messages_to_text(payload["messages"])
+    payload["image_path_list"] = image_path_list
+    return payload
+
+
+# ── Routes ──
+
+@app.post("/process")
+async def process_images(request: RequestModel) -> Dict[str, Any]:
+    return await process_request(request.messages, request.image_path_list)
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
+
+
+# ── Entrypoint ──
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=10044)