TeleCoder3-36B-Thinking

Browse files

Files changed (12) hide show

.gitattributes +2 -0
Demo/五子棋.gif +3 -0
Demo/五子棋.html +525 -0
Demo/大鱼吃小鱼.gif +3 -0
Demo/大鱼吃小鱼.html +562 -0
README.md +284 -0
TeleCoder3_vllm_tool_parser/.gitignore +2 -0
TeleCoder3_vllm_tool_parser/README.md +12 -0
TeleCoder3_vllm_tool_parser/setup.py +15 -0
TeleCoder3_vllm_tool_parser/telechat3_reasoning.py +32 -0
TeleCoder3_vllm_tool_parser/telechat3_tool_parser.py +175 -0
images/TeleCoder3_post_training.png +0 -0

.gitattributes CHANGED Viewed

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text

 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Demo/大鱼吃小鱼.gif filter=lfs diff=lfs merge=lfs -text
+Demo/五子棋.gif filter=lfs diff=lfs merge=lfs -text

Demo/五子棋.gif ADDED Viewed

Git LFS Details

SHA256: 60bea5996fb11c09b049b047178903681a68674fb64e6f306d1ddd88a0c5fcc9
Pointer size: 131 Bytes
Size of remote file: 194 kB

Demo/五子棋.html ADDED Viewed

	@@ -0,0 +1,525 @@

+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>五子棋 - 网页版</title>
+    <style>
+        :root {
+            --board-bg: #e3c086;
+            --board-line: #5d4037;
+            --p1-color: #111; /* 黑棋 */
+            --p2-color: #f0f0f0; /* 白棋 */
+            --highlight: #ff4757; /* 最后一手的标记颜色 */
+            --primary-btn: #2ed573;
+            --primary-btn-hover: #26af61;
+        }
+        body {
+            font-family: 'PingFang SC', 'Microsoft YaHei', sans-serif;
+            background-color: #f7f1e3;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            min-height: 100vh;
+            margin: 0;
+            user-select: none;
+        }
+        header {
+            margin-bottom: 20px;
+            text-align: center;
+        }
+        h1 {
+            color: #2f3542;
+            margin: 0;
+            font-size: 2rem;
+            letter-spacing: 2px;
+        }
+        .game-wrapper {
+            display: flex;
+            gap: 30px;
+            flex-wrap: wrap;
+            justify-content: center;
+            align-items: flex-start;
+            padding: 20px;
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 10px 25px rgba(0,0,0,0.1);
+        }
+        /* 棋盘区域 */
+        .board-container {
+            position: relative;
+            padding: 15px;
+            background-color: var(--board-bg);
+            border-radius: 4px;
+            box-shadow: inset 0 0 10px rgba(0,0,0,0.3), 5px 5px 15px rgba(0,0,0,0.2);
+            /* 棋盘纹理效果 */
+            background-image: linear-gradient(45deg, rgba(0,0,0,0.03) 25%, transparent 25%, transparent 75%, rgba(0,0,0,0.03) 75%, rgba(0,0,0,0.03)),
+                              linear-gradient(45deg, rgba(0,0,0,0.03) 25%, transparent 25%, transparent 75%, rgba(0,0,0,0.03) 75%, rgba(0,0,0,0.03));
+            background-size: 20px 20px;
+            background-position: 0 0, 10px 10px;
+        }
+        .board {
+            display: grid;
+            grid-template-columns: repeat(15, 30px);
+            grid-template-rows: repeat(15, 30px);
+            gap: 0;
+            position: relative;
+            cursor: pointer;
+        }
+        /* 棋盘格子与线条 */
+        .cell {
+            width: 30px;
+            height: 30px;
+            position: relative;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        /* 绘制棋盘线：利用伪元素模拟交叉点 */
+        .cell::before {
+            content: '';
+            position: absolute;
+            top: 50%;
+            left: 0;
+            width: 100%;
+            height: 1px;
+            background-color: var(--board-line);
+            z-index: 0;
+        }
+        .cell::after {
+            content: '';
+            position: absolute;
+            left: 50%;
+            top: 0;
+            height: 100%;
+            width: 1px;
+            background-color: var(--board-line);
+            z-index: 0;
+        }
+        /* 天元和星位小黑点 (可选，仅作装饰) */
+        .cell.star-point::before {
+            width: 100%; /* 保持线条贯穿 */
+        }
+        .cell.star-point .dot {
+            position: absolute;
+            width: 6px;
+            height: 6px;
+            background: var(--board-line);
+            border-radius: 50%;
+            z-index: 1;
+        }
+        /* 棋子通用样式 */
+        .piece {
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            z-index: 2;
+            transform: scale(0);
+            transition: transform 0.2s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+            box-shadow: 2px 2px 4px rgba(0,0,0,0.4);
+        }
+        .piece.show {
+            transform: scale(1);
+        }
+        /* 玩家1 - 黑棋 */
+        .piece.p1 {
+            background: radial-gradient(circle at 30% 30%, #555, #000);
+        }
+        /* 玩家2 - 白棋 */
+        .piece.p2 {
+            background: radial-gradient(circle at 30% 30%, #fff, #ddd);
+            border: 1px solid #ccc;
+        }
+        /* 最新落子标记 */
+        .piece.last-move::after {
+            content: '';
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 6px;
+            height: 6px;
+            background-color: var(--highlight);
+            border-radius: 50%;
+            box-shadow: 0 0 4px rgba(255, 71, 87, 0.8);
+        }
+        /* 鼠标悬停预览 */
+        .cell:hover:not(.occupied) .preview {
+            display: block;
+        }
+        .preview {
+            display: none;
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            opacity: 0.4;
+            z-index: 1;
+        }
+        .preview.p1 { background-color: #000; }
+        .preview.p2 { background-color: #fff; }
+        /* 侧边栏控制区 */
+        .sidebar {
+            width: 200px;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 20px;
+        }
+        .status-card {
+            background: #f1f2f6;
+            padding: 20px;
+            border-radius: 8px;
+            width: 100%;
+            text-align: center;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+        }
+        .status-title {
+            font-size: 0.9rem;
+            color: #747d8c;
+            margin-bottom: 10px;
+        }
+        .current-player-indicator {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 10px;
+            font-size: 1.2rem;
+            font-weight: bold;
+            margin-bottom: 15px;
+        }
+        .indicator-dot {
+            width: 20px;
+            height: 20px;
+            border-radius: 50%;
+            border: 1px solid #ccc;
+        }
+        .message-area {
+            min-height: 40px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-weight: bold;
+            color: #2f3542;
+        }
+        .message-area.win { color: var(--primary-btn); }
+        .message-area.draw { color: #ffa502; }
+        button {
+            background-color: var(--primary-btn);
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            font-size: 1rem;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: background 0.2s, transform 0.1s;
+            width: 100%;
+            font-weight: bold;
+        }
+        button:hover {
+            background-color: var(--primary-btn-hover);
+        }
+        button:active {
+            transform: scale(0.98);
+        }
+        /* 响应式调整 */
+        @media (max-width: 600px) {
+            .game-wrapper {
+                flex-direction: column;
+                align-items: center;
+            }
+            .sidebar {
+                width: 100%;
+                flex-direction: row;
+                justify-content: space-between;
+                box-sizing: border-box;
+                padding: 10px;
+            }
+            .status-card {
+                flex: 1;
+                margin-right: 10px;
+            }
+            button {
+                width: auto;
+                padding: 10px 20px;
+            }
+            .board {
+                /* 移动端稍微缩小棋盘 */
+                grid-template-columns: repeat(15, 22px);
+                grid-template-rows: repeat(15, 22px);
+            }
+            .cell {
+                width: 22px;
+                height: 22px;
+            }
+            .piece {
+                width: 18px;
+                height: 18px;
+            }
+            .preview {
+                width: 18px;
+                height: 18px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <header>
+        <h1>五子棋</h1>
+    </header>
+    <main class="game-wrapper">
+        <!-- 棋盘区域 -->
+        <div class="board-container">
+            <div class="board" id="board"></div>
+        </div>
+        <!-- 控制与状态区域 -->
+        <aside class="sidebar">
+            <div class="status-card">
+                <div class="status-title">游戏状态</div>
+                <div class="current-player-indicator">
+                    <span id="playerDot" class="indicator-dot" style="background: #000;"></span>
+                    <span id="statusText">游戏开始！玩家1先落子</span>
+                </div>
+                <div class="message-area" id="messageArea">
+                    等待落子...
+                </div>
+            </div>
+            <button id="restartBtn" onclick="game.restart()">重新开始</button>
+        </aside>
+    </main>
+    <script>
+        /**
+         * 游戏逻辑控制器
+         */
+        const game = {
+            size: 15, // 15x15 棋盘
+            boardData: [], // 存储棋盘状态: 0=空, 1=玩家1(黑), 2=玩家2(白)
+            currentPlayer: 1, // 1 或 2
+            isGameOver: false,
+            moveCount: 0,
+            maxMoves: 15 * 15,
+            lastMove: null, // {r, c} 记录最后一步，用于高亮
+            // DOM 元素引用
+            boardEl: document.getElementById('board'),
+            statusTextEl: document.getElementById('statusText'),
+            messageAreaEl: document.getElementById('messageArea'),
+            playerDotEl: document.getElementById('playerDot'),
+            restartBtn: document.getElementById('restartBtn'),
+            // 初始化游戏
+            init() {
+                this.createBoard();
+                this.restart();
+            },
+            // 创建棋盘网格 HTML
+            createBoard() {
+                this.boardEl.innerHTML = '';
+                for (let r = 0; r < this.size; r++) {
+                    for (let c = 0; c < this.size; c++) {
+                        const cell = document.createElement('div');
+                        cell.classList.add('cell');
+                        cell.dataset.row = r;
+                        cell.dataset.col = c;
+                        // 添加星位 (标准五子棋星位位置: 3,3; 11,3; 7,7; 3,11; 11,11)
+                        if ((r === 3 || r === 11 || r === 7) && (c === 3 || c === 11 || c === 7)) {
+                            const dot = document.createElement('div');
+                            dot.classList.add('dot');
+                            cell.classList.add('star-point');
+                            cell.appendChild(dot);
+                        }
+                        // 添加预览棋子 (根据当前回合)
+                        const preview = document.createElement('div');
+                        preview.classList.add('preview', `p${this.currentPlayer}`);
+                        cell.appendChild(preview);
+                        // 绑定点击事件
+                        cell.addEventListener('click', () => this.handleMove(r, c));
+                        this.boardEl.appendChild(cell);
+                    }
+                }
+            },
+            // 重新开始
+            restart() {
+                this.boardData = Array(this.size).fill(null).map(() => Array(this.size).fill(0));
+                this.currentPlayer = 1;
+                this.isGameOver = false;
+                this.moveCount = 0;
+                this.lastMove = null;
+                // 清除所有棋子和状态
+                const cells = document.querySelectorAll('.cell');
+                cells.forEach(cell => {
+                    // 移除 .occupied 类（虽然这里没用这个类做太多，但逻辑上表示被占用了）
+                    cell.classList.remove('occupied');
+                    const piece = cell.querySelector('.piece');
+                    if (piece) piece.remove();
+                    // 重置预览
+                    const preview = cell.querySelector('.preview');
+                    if(preview) {
+                        preview.className = `preview p${this.currentPlayer}`;
+                    }
+                });
+                this.updateUI();
+                this.messageAreaEl.textContent = "游戏开始！玩家1先落子";
+                this.messageAreaEl.className = "message-area";
+                this.statusTextEl.textContent = "轮到玩家1";
+            },
+            // 处理落子
+            handleMove(r, c) {
+                // 如果游戏结束或该位置已有棋子，则忽略
+                if (this.isGameOver || this.boardData[r][c] !== 0) return;
+                // 1. 更新数据
+                this.boardData[r][c] = this.currentPlayer;
+                this.moveCount++;
+                this.lastMove = { r, c };
+                // 2. 更新 UI：移除预览，添加正式棋子
+                const cell = this.getCell(r, c);
+                const preview = cell.querySelector('.preview');
+                if (preview) preview.style.display = 'none';
+                const piece = document.createElement('div');
+                piece.classList.add('piece', `p${this.currentPlayer}`, 'show');
+                // 移除旧的高亮，添加新的高亮
+                const prevLast = document.querySelector('.piece.last-move');
+                if (prevLast) prevLast.classList.remove('last-move');
+                piece.classList.add('last-move');
+                cell.appendChild(piece);
+                // 3. 检查胜负
+                if (this.checkWin(r, c, this.currentPlayer)) {
+                    this.endGame(true);
+                    return;
+                }
+                // 4. 检查平局
+                if (this.moveCount === this.maxMoves) {
+                    this.endGame(false);
+                    return;
+                }
+                // 5. 切换玩家
+                this.currentPlayer = this.currentPlayer === 1 ? 2 : 1;
+                // 更新所有格子的悬停预览颜色（因为换了玩家）
+                this.updatePreviews();
+                this.updateUI();
+            },
+            // 更新界面文字和指示器
+            updateUI() {
+                this.statusTextEl.textContent = `轮到玩家${this.currentPlayer}`;
+                this.playerDotEl.style.background = this.currentPlayer === 1 ? '#000' : '#fff';
+                this.playerDotEl.style.border = this.currentPlayer === 1 ? 'none' : '1px solid #ccc';
+            },
+            // 更新棋盘上的悬停预览颜色
+            updatePreviews() {
+                const previews = document.querySelectorAll('.preview');
+                previews.forEach(p => {
+                    p.className = `preview p${this.currentPlayer}`;
+                });
+            },
+            // 获取 DOM 单元格
+            getCell(r, c) {
+                // 由于 grid 是平铺的，索引 = r * size + c
+                return this.boardEl.children[r * this.size + c];
+            },
+            // 核心算法：检查胜利
+            checkWin(r, c, player) {
+                const directions = [
+                    [[0, 1], [0, -1]], // 水平
+                    [[1, 0], [-1, 0]], // 垂直
+                    [[1, 1], [-1, -1]], // 右下斜
+                    [[1, -1], [-1, 1]]  // 左下斜
+                ];
+                for (let axis of directions) {
+                    let count = 1; // 包含当前落子
+                    for (let dir of axis) {
+                        let nr = r + dir[0];
+                        let nc = c + dir[1];
+                        while (
+                            nr >= 0 && nr < this.size &&
+                            nc >= 0 && nc < this.size &&
+                            this.boardData[nr][nc] === player
+                        ) {
+                            count++;
+                            nr += dir[0];
+                            nc += dir[1];
+                        }
+                    }
+                    if (count >= 5) return true;
+                }
+                return false;
+            },
+            // 游戏结束处理
+            endGame(hasWinner) {
+                this.isGameOver = true;
+                if (hasWinner) {
+                    const winnerName = this.currentPlayer === 1 ? "玩家1 (黑)" : "玩家2 (白)";
+                    this.messageAreaEl.textContent = `${winnerName} 获胜！`;
+                    this.messageAreaEl.className = "message-area win";
+                    this.statusTextEl.textContent = "游戏结束";
+                } else {
+                    this.messageAreaEl.textContent = "平局！";
+                    this.messageAreaEl.className = "message-area draw";
+                    this.statusTextEl.textContent = "游戏结束";
+                }
+            }
+        };
+        // 启动游戏
+        game.init();
+    </script>
+</body>
+</html>

Demo/大鱼吃小鱼.gif ADDED Viewed

Git LFS Details

SHA256: 2504f4e795341d10b3154b1afb39ba381f09160ca7c6cada790c7d2ddcbac047
Pointer size: 132 Bytes
Size of remote file: 1.84 MB

Demo/大鱼吃小鱼.html ADDED Viewed

	@@ -0,0 +1,562 @@

+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>大鱼吃小鱼</title>
+    <style>
+        :root {
+            --water-top: #006994;
+            --water-bottom: #001e36;
+            --ui-bg: rgba(255, 255, 255, 0.9);
+            --accent-color: #ff9800;
+            --text-color: #333;
+        }
+        body {
+            margin: 0;
+            padding: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            background-color: #222;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            overflow: hidden;
+        }
+        /* 游戏主容器 */
+        #game-wrapper {
+            position: relative;
+            width: 800px;
+            height: 600px;
+            box-shadow: 0 0 50px rgba(0, 0, 0, 0.5);
+            border-radius: 12px;
+            overflow: hidden;
+            background: linear-gradient(to bottom, var(--water-top), var(--water-bottom));
+        }
+        canvas {
+            display: block;
+            width: 100%;
+            height: 100%;
+        }
+        /* UI 面板 */
+        #ui-panel {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            padding: 15px 20px;
+            box-sizing: border-box;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            pointer-events: none; /* 让点击穿透到Canvas，除非是按钮 */
+        }
+        .score-board {
+            background: rgba(0, 0, 0, 0.4);
+            color: white;
+            padding: 8px 16px;
+            border-radius: 20px;
+            font-size: 18px;
+            font-weight: bold;
+            pointer-events: auto;
+        }
+        .controls-hint {
+            color: rgba(255, 255, 255, 0.7);
+            font-size: 14px;
+            pointer-events: auto;
+        }
+        /* 状态消息区 */
+        #status-message {
+            position: absolute;
+            bottom: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            background: rgba(0, 0, 0, 0.5);
+            color: #fff;
+            padding: 8px 20px;
+            border-radius: 4px;
+            font-size: 14px;
+            opacity: 0;
+            transition: opacity 0.3s;
+            pointer-events: none;
+        }
+        /* 模态框 (开始/结束/胜利) */
+        #modal-overlay {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.6);
+            backdrop-filter: blur(4px);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            z-index: 10;
+        }
+        .modal-content {
+            background: white;
+            padding: 40px;
+            border-radius: 16px;
+            text-align: center;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
+            max-width: 400px;
+            animation: popIn 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+        }
+        @keyframes popIn {
+            from { transform: scale(0.8); opacity: 0; }
+            to { transform: scale(1); opacity: 1; }
+        }
+        h1 { margin: 0 0 10px; color: var(--water-top); }
+        h2 { margin: 0 0 20px; color: var(--text-color); }
+        p { color: #666; margin-bottom: 30px; line-height: 1.5; }
+        .btn {
+            background-color: var(--accent-color);
+            color: white;
+            border: none;
+            padding: 12px 30px;
+            font-size: 18px;
+            border-radius: 30px;
+            cursor: pointer;
+            transition: transform 0.1s, background-color 0.2s;
+            font-weight: bold;
+            outline: none;
+        }
+        .btn:hover { background-color: #e68900; transform: scale(1.05); }
+        .btn:active { transform: scale(0.95); }
+        .hidden { display: none !important; }
+    </style>
+</head>
+<body>
+    <div id="game-wrapper">
+        <canvas id="gameCanvas" width="800" height="600"></canvas>
+        <!-- 顶部UI -->
+        <div id="ui-panel">
+            <div class="score-board">得分: <span id="score-display">0</span></div>
+            <div class="controls-hint">使用方向键 ↑ ↓ ← → 控制移动</div>
+        </div>
+        <!-- 底部消息反馈 -->
+        <div id="status-message">游戏开始！</div>
+        <!-- 游戏状态弹窗 -->
+        <div id="modal-overlay">
+            <div class="modal-content" id="start-screen">
+                <h1>大鱼吃小鱼</h1>
+                <p>
+                    吃掉比你小的鱼来成长。<br>
+                    躲避比你大的鱼！<br>
+                    目标：达到最大的体型（半径50）。
+                </p>
+                <button class="btn" onclick="game.start()">开始游戏</button>
+            </div>
+            <div class="modal-content hidden" id="game-over-screen">
+                <h2 style="color: #d32f2f;">被大鱼吃掉了！</h2>
+                <p>最终得分: <span id="final-score-loss">0</span></p>
+                <button class="btn" onclick="game.restart()">重新开始</button>
+            </div>
+            <div class="modal-content hidden" id="victory-screen">
+                <h2 style="color: #388e3c;">成为最大的鱼！</h2>
+                <p>恭喜你通关成功！<br>你已经是海洋霸主了。</p>
+                <p>最终得分: <span id="final-score-win">0</span></p>
+                <button class="btn" onclick="game.restart()">再玩一次</button>
+            </div>
+        </div>
+    </div>
+<script>
+/**
+ * 游戏配置与常量
+ */
+const CONFIG = {
+    friction: 0.95, // 移动摩擦力
+    playerBaseSpeed: 0.5,
+    playerMaxSpeed: 6,
+    enemyBaseSpeed: 2,
+    winRadius: 50,   // 胜利半径
+    spawnRate: 60,   // 每多少帧尝试生成敌人 (越小越快)
+    colors: {
+        player: '#FF9800',
+        small: '#4CAF50', // 绿色：可吃
+        big: '#F44336'    // 红色：危险
+    }
+};
+/**
+ * 鱼类基类
+ */
+class Fish {
+    constructor(x, y, radius, color, isPlayer = false) {
+        this.x = x;
+        this.y = y;
+        this.radius = radius;
+        this.color = color;
+        this.isPlayer = isPlayer;
+        this.angle = 0; // 面向角度
+        // 速度向量
+        this.velocity = { x: 0, y: 0 };
+        if (isPlayer) {
+            this.speed = CONFIG.playerBaseSpeed;
+        } else {
+            this.speed = Math.random() * 1.5 + 0.5; // 随机速度
+            // 敌人随机方向
+            this.angle = Math.random() * Math.PI * 2;
+            this.updateVelocity();
+        }
+    }
+    updateVelocity() {
+        // 根据当前角度设置速度向量
+        this.velocity.x = Math.cos(this.angle) * this.speed;
+        this.velocity.y = Math.sin(this.angle) * this.speed;
+    }
+    move() {
+        this.x += this.velocity.x;
+        this.y += this.velocity.y;
+    }
+    // 边界反弹
+    checkBounds(width, height) {
+        if (this.x - this.radius < 0) {
+            this.x = this.radius;
+            this.angle = Math.PI - this.angle;
+            this.updateVelocity();
+        }
+        if (this.x + this.radius > width) {
+            this.x = width - this.radius;
+            this.angle = Math.PI - this.angle;
+            this.updateVelocity();
+        }
+        if (this.y - this.radius < 0) {
+            this.y = this.radius;
+            this.angle = -this.angle;
+            this.updateVelocity();
+        }
+        if (this.y + this.radius > height) {
+            this.y = height - this.radius;
+            this.angle = -this.angle;
+            this.updateVelocity();
+        }
+    }
+    draw(ctx) {
+        ctx.save();
+        ctx.translate(this.x, this.y);
+        ctx.rotate(this.angle);
+        // 身体
+        ctx.beginPath();
+        ctx.fillStyle = this.color;
+        ctx.arc(0, 0, this.radius, 0, Math.PI * 2);
+        ctx.fill();
+        // 眼睛
+        ctx.beginPath();
+        ctx.fillStyle = 'white';
+        ctx.arc(this.radius * 0.4, -this.radius * 0.3, this.radius * 0.25, 0, Math.PI * 2);
+        ctx.fill();
+        ctx.beginPath();
+        ctx.fillStyle = 'black';
+        ctx.arc(this.radius * 0.5, -this.radius * 0.3, this.radius * 0.1, 0, Math.PI * 2);
+        ctx.fill();
+        // 尾巴
+        ctx.beginPath();
+        ctx.fillStyle = this.color;
+        ctx.moveTo(-this.radius * 0.8, 0);
+        ctx.lineTo(-this.radius * 1.5, -this.radius * 0.6);
+        ctx.lineTo(-this.radius * 1.5, this.radius * 0.6);
+        ctx.fill();
+        ctx.restore();
+    }
+    grow(amount) {
+        this.radius += amount;
+    }
+}
+/**
+ * 游戏主逻辑类
+ */
+class Game {
+    constructor() {
+        this.canvas = document.getElementById('gameCanvas');
+        this.ctx = this.canvas.getContext('2d');
+        this.width = this.canvas.width;
+        this.height = this.canvas.height;
+        this.score = 0;
+        this.state = 'START'; // START, PLAYING, GAME_OVER, VICTORY
+        this.frameCount = 0;
+        // 实体
+        this.player = null;
+        this.enemies = [];
+        this.particles = []; // 可以添加吃鱼特效
+        // 输入状态
+        this.keys = {
+            ArrowUp: false,
+            ArrowDown: false,
+            ArrowLeft: false,
+            ArrowRight: false
+        };
+        this.bindEvents();
+    }
+    bindEvents() {
+        window.addEventListener('keydown', (e) => {
+            if (this.keys.hasOwnProperty(e.code)) this.keys[e.code] = true;
+        });
+        window.addEventListener('keyup', (e) => {
+            if (this.keys.hasOwnProperty(e.code)) this.keys[e.code] = false;
+        });
+    }
+    init() {
+        // 初始化玩家
+        this.player = new Fish(this.width / 2, this.height / 2, 10, CONFIG.colors.player, true);
+        this.enemies = [];
+        this.score = 0;
+        this.frameCount = 0;
+        this.updateUI();
+        this.showMessage("准备开始...");
+    }
+    start() {
+        this.init();
+        this.state = 'PLAYING';
+        this.hideModals();
+        this.animate();
+    }
+    restart() {
+        this.start();
+    }
+    spawnEnemy() {
+        // 在边缘生成敌人
+        let x, y;
+        if (Math.random() < 0.5) {
+            x = Math.random() < 0.5 ? -30 : this.width + 30;
+            y = Math.random() * this.height;
+        } else {
+            x = Math.random() * this.width;
+            y = Math.random() < 0.5 ? -30 : this.height + 30;
+        }
+        // 随机大小：有的比玩家小，有的比玩家大
+        // 动态调整：确保大概50%概率比玩家小，50%比玩家大，但差距适中
+        let sizeVariation = Math.random();
+        let radius;
+        if (sizeVariation > 0.5) {
+            // 生成比玩家小的 (食物)
+            radius = Math.max(5, this.player.radius * (0.5 + Math.random() * 0.4));
+        } else {
+            // 生成比玩家大的 (威胁)
+            radius = this.player.radius * (1.2 + Math.random() * 1.5);
+            // 限制最大尺寸，防止生成无敌怪
+            if (radius > 100) radius = 100;
+        }
+        // 颜色逻辑
+        let color = CONFIG.colors.small;
+        if (radius > this.player.radius) color = CONFIG.colors.big;
+        const enemy = new Fish(x, y, radius, color);
+        // 让敌人朝向玩家大概方向移动，增加互动感
+        const angleToPlayer = Math.atan2(this.player.y - y, this.player.x - x);
+        // 增加一些随机偏移，不要死板地冲向玩家
+        const variance = (Math.random() - 0.5);
+        enemy.angle = angleToPlayer + variance;
+        enemy.updateVelocity();
+        this.enemies.push(enemy);
+    }
+    handleInput() {
+        if (this.state !== 'PLAYING') return;
+        // 玩家控制逻辑
+        if (this.keys.ArrowUp) {
+            this.player.velocity.y -= CONFIG.playerBaseSpeed;
+            this.player.angle = -Math.PI / 2;
+        }
+        if (this.keys.ArrowDown) {
+            this.player.velocity.y += CONFIG.playerBaseSpeed;
+            this.player.angle = Math.PI / 2;
+        }
+        if (this.keys.ArrowLeft) {
+            this.player.velocity.x -= CONFIG.playerBaseSpeed;
+            this.player.angle = Math.PI;
+        }
+        if (this.keys.ArrowRight) {
+            this.player.velocity.x += CONFIG.playerBaseSpeed;
+            this.player.angle = 0;
+        }
+        // 限制最大速度
+        const speed = Math.sqrt(this.player.velocity.x**2 + this.player.velocity.y**2);
+        if (speed > CONFIG.playerMaxSpeed) {
+            const ratio = CONFIG.playerMaxSpeed / speed;
+            this.player.velocity.x *= ratio;
+            this.player.velocity.y *= ratio;
+        }
+        // 应用摩擦力
+        this.player.velocity.x *= CONFIG.friction;
+        this.player.velocity.y *= CONFIG.friction;
+    }
+    checkCollisions() {
+        for (let i = this.enemies.length - 1; i >= 0; i--) {
+            const enemy = this.enemies[i];
+            const dx = this.player.x - enemy.x;
+            const dy = this.player.y - enemy.y;
+            const distance = Math.sqrt(dx * dx + dy * dy);
+            // 碰撞发生
+            if (distance < this.player.radius + enemy.radius) {
+                if (this.player.radius >= enemy.radius) {
+                    // 玩家吃掉敌人
+                    this.score += Math.floor(enemy.radius);
+                    this.player.grow(enemy.radius * 0.05); // 缓慢成长
+                    // 视觉反馈
+                    this.showMessage(`吞噬成功! +${Math.floor(enemy.radius)}分`);
+                    // 移除敌人
+                    this.enemies.splice(i, 1);
+                    this.updateUI();
+                    // 胜利检测
+                    if (this.player.radius >= CONFIG.winRadius) {
+                        this.victory();
+                    }
+                } else {
+                    // 玩家被吃
+                    this.gameOver();
+                }
+            }
+        }
+    }
+    update() {
+        if (this.state !== 'PLAYING') return;
+        this.handleInput();
+        // 移动玩家
+        this.player.move();
+        this.player.checkBounds(this.width, this.height);
+        // 移动敌人 & 生成
+        this.frameCount++;
+        if (this.frameCount % CONFIG.spawnRate === 0) {
+            this.spawnEnemy();
+        }
+        for (let i = this.enemies.length - 1; i >= 0; i--) {
+            this.enemies[i].move();
+            // 简单的边界检查，防止它们在内部乱飞太远
+            // (如果从外部生成，其实不需要，但如果它们被打散就��要)
+            this.enemies[i].checkBounds(this.width, this.height);
+        }
+        this.checkCollisions();
+    }
+    draw() {
+        // 清空画布
+        this.ctx.clearRect(0, 0, this.width, this.height);
+        // 绘制玩家
+        if (this.player) this.player.draw(this.ctx);
+        // 绘制敌人
+        this.enemies.forEach(enemy => enemy.draw(this.ctx));
+    }
+    animate() {
+        if (this.state === 'PLAYING') {
+            this.update();
+            this.draw();
+            requestAnimationFrame(() => this.animate());
+        }
+    }
+    updateUI() {
+        document.getElementById('score-display').innerText = this.score;
+    }
+    showMessage(text) {
+        const el = document.getElementById('status-message');
+        el.innerText = text;
+        el.style.opacity = 1;
+        // 清除之前的定时器（简单处理）
+        if (this.msgTimeout) clearTimeout(this.msgTimeout);
+        this.msgTimeout = setTimeout(() => {
+            el.style.opacity = 0;
+        }, 2000);
+    }
+    gameOver() {
+        this.state = 'GAME_OVER';
+        document.getElementById('final-score-loss').innerText = this.score;
+        this.showModal('game-over-screen');
+        this.showMessage("被大鱼吃掉了！游戏失败");
+    }
+    victory() {
+        this.state = 'VICTORY';
+        document.getElementById('final-score-win').innerText = this.score;
+        this.showModal('victory-screen');
+        this.showMessage("成为最大的鱼！通关成功");
+    }
+    hideModals() {
+        document.querySelectorAll('.modal-content').forEach(el => el.classList.add('hidden'));
+        document.getElementById('modal-overlay').classList.add('hidden');
+    }
+    showModal(id) {
+        this.hideModals();
+        document.getElementById(id).classList.remove('hidden');
+        document.getElementById('modal-overlay').classList.remove('hidden');
+    }
+}
+// 启动游戏实例
+const game = new Game();
+</script>
+</body>
+</html>

README.md ADDED Viewed

	@@ -0,0 +1,284 @@

+<div align="center">
+<h1>
+  TeleCoder3
+</h1>
+</div>
+<p align="center">
+   🦉 <a href="https://github.com/Tele-AI/TeleCoder3" target="_blank">github</a> • 🤗 <a href="https://huggingface.co/Tele-AI" target="_blank">Hugging Face</a> • 🤖 <a href="https://modelscope.cn/organization/TeleAI" target="_blank">ModelScope</a> • 💬 <a href="https://github.com/Tele-AI/Telechat/blob/master/images/wechat.jpg" target="_blank">WeChat</a>
+</p>
+# 目录
+- [模型介绍](#模型介绍)
+- [能力评估](#能力评估)
+- [推理](#gpu-推理)
+- [国产化适配](#国产化适配)
+- [声明、协议、引用](#声明协议引用)
+# 最新动态
+- 2026.01.30 开源 **TeleCoder3-36B-Thinking**
+# 模型介绍
+### 星辰语义代码大模型-TeleCoder3
+- 星辰语义代码大模型 **TeleCoder3** 是由中国电信人工智能研究院研发训练的大语言模型，该模型**完全基于国产算力**训练。
+### 技术创新
+#### 预训练
+**TeleCoder3-36B-Thinking** 在 TeleBase3 基础上持续进行三阶段代码预训练：
+- 第一阶段：在 TeleBase3 的基础上，将通用代码数据占比提升至 70%，并基于 8K 上下文长度进行持续训练，以增强模型的代码通识能力；
+- 第二阶段：优化代码数据组成，尤其增加了高质量仓库级别代码长文数据、SWE 级别长程代码任务数据等，以相同数据配比，基于 32K 上下文长度开展持续训练，增加模型长文任务能力；
+- 第三阶段：进一步提升长程代码任务与智能体任务数据占比，并基于 128K 上下文长度进行持续训练，持续增强模型在代码与智能体长程任务场景下的综合能力。
+#### 后训练
+- 为进一步提升代码能力与 Agent 任务表现，我们在推理阶段引入 Interleaved Thinking 机制，并通过大量实验验证其在多轮工具交互场景下具备较明显优势；
+- 为提升 Agentic Coding 能力，我们搭建了上万个执行环境，用于合成任务轨迹数据，并支撑 Agentic RL 训练；
+- 为提升 Web Vibe Coding 效果，我们基于 GUI-Agent 构建了一套可自动操作 Web 界面并进行生成结果评估的系统，大幅提升了数据质量。
+**TeleCoder3-36B-Thinking** 后训练采用迭代式提升方案：
+- 第一阶段：模型冷启动微调，主要提升模型通用代码、Agent、推理、指令理解等能力，为了取得更好的冷启动效果，针对微调数据难度和多样性做了大量筛选工作；
+- 第二阶段：强化学习，采用了基于规则校验奖励和 RM 打分模型融合的方式，对模型综合能力进行进一步强化；
+- 第三阶段：在上一阶段模型基础上，开展长程 Agent 与 Coding 任务的专项微调优化；
+- 第四阶段：主要通过 Agentic RL 训练策略优化模型长程任务能力。
+![post-training](./images/TeleCoder3_post_training.png)
+### 模型结构
+**TeleCoder3-36B-Thinking** 的模型结构配置和 **TeleChat3-36B-Thinking** 一致：
+|      | Layers | Hidden Size | FFN Intermediate | Attention |
+|------|-----------|------|------|-----|
+| TeleCoder3-36B-Thinking  | 64        | 6144        | 24576   | GQA |
+# 能力评估
+**TeleCoder3-36B-Thinking** 在代码综合能力上，不论是 Agentic Coding 还是通用代码类任务均有很好表现，同尺寸模型效果达到最优水平；
+**TeleCoder3-36B-Thinking** 在 Agent 能力上同样表现很好，在 BFCL 和 Tau2-Bench 榜单上达到同级别参数较好水平。
+| 评测集                        | 任务类型  | Kimi-Dev-72B | Qwen3-32B-Thinking | Qwen3-30B-A3B-2507 | Qwen3-Coder-480B-A35B-Instruct | TeleCoder3-36B-Thinking |
+|----------------------------|-------|---------------|--------------------|-----------|--------------|----------------------|
+| IFEval                   | 指令    | -          | **85**               | 81.2     | 82.4        | **84.6**                 |
+| SWE-bench Verified                   | 代码    | 60.4          | 28               | 51.6     | **69.6**        | **65**                 |
+| Terminal Bench                   | 代码    | -          | 1.2               | 31.3     | **37.5**        | **34.8**                 |
+| Livecodebench(24.08-25.05)                   | 代码    | 51.5          | 66.7               | 42.5     | 57.5        | **78.2**                 |
+| ArtifactsBench                   | 代码    | -          | 64.3               | 73.8     | 78.7        | **82.8**                 |
+| HumanEval-X                   | 代码    | 67.44          | 84.3               | 88.9     | **91.7**        | 88.9                 |
+| MBPP-Plus                   | 代码    | -          | **83.9**               | 79.9     | 79.4        | **84.2**                 |
+| CRUXEval                   | 代码    | -          | **95**               | 74.1     | 75.9        | 89.7                 |
+| BFCL-V3                   | Agent    | -          | **70.3**          | 59.2               | 68.7     | **70.5**                 |
+| Tau2-Bench                   | Agent    | -          | 41.7          | 31.2               | 47     | **70**                 |
+### 代码场景 Cases
+#### Case1: 大鱼吃小鱼
+**Prompt**
+```markdown
+**游戏名称**: 大鱼吃小鱼
+**基本功能**:
+1. 游戏界面为水域风格的操作区域，包含核心元素：
+   - 玩家小鱼（可操控角色，有基础大小）；
+   - 其他鱼（不同大小的鱼类，随机分布在操作区域）；
+   - 基础功能区：显示当前得分、“开始/重新开始”按钮；
+   - 简单提示区：文字显示吃小鱼得分、被大鱼吃掉、游戏胜利/失败等反馈。
+2. 核心交互规则：
+   - 操控逻辑：方向键（上下左右）控制玩家小鱼在水域内自由移动，无法超出操作区域边界；
+   - 吞噬规则：
+     ① 吃小鱼：玩家小鱼接触到比自身小的鱼时，判定吞噬成功，被吞噬的鱼消失，玩家小鱼体型变大，得分增加，提示吞噬成功；
+     ② 被大鱼吃：玩家小鱼接触到比自身大的鱼时，立即判定游戏失败，禁用所有操作，提示“被大鱼吃掉！游戏失败”；
+   - 胜利判定：玩家小鱼吞噬足够多的小鱼，体型达到设定的最大尺寸时，判定游戏胜利，禁用所有操作，提示“成为最大的鱼！通关成功”；
+   - 鱼类生成：游戏开始后，不同大小的鱼会随机出现在操作区域，数量和移动速度由代码合理控制。
+3. 基础玩法：
+   1. 游戏初始化后，点击“开始”按钮启动游戏，各类鱼开始随机移动；
+   2. 玩家通过方向键操控小鱼移动，优先吞噬比自己小的鱼长大，避开比自己大的鱼；
+   3. 游戏失败/胜利后，点击“重新开始”可重置小鱼体型、得分和所有鱼类位置，重新游玩。
+请基于上述要求编写完整HTML代码
+```
+**代码生成效果**
+<div align="center">
+    <img src="./Demo/大鱼吃小鱼.gif" width="50%" alt="大鱼吃小鱼演示">
+    <p>👉点击体验 <a href="./Demo/大鱼吃小鱼.html">大鱼吃小鱼</a></p>
+</div>
+#### Case2: 五子棋
+**Prompt**
+```markdown
+**游戏名称**: 五子棋
+**基本功能**:
+1. 游戏界面为网格形式的对弈区域，包含核心元素：
+   - 空白网格（供落子）；
+   - 两种不同标识的棋子（区分两位玩家）；
+   - 基础功能区：显示当前落子方、“重新开始”按钮；
+   - 简单提示区：文字显示获胜方、平局（可选）等反馈。
+2. 核心交互规则：
+   - 落子逻辑：
+     ① 玩家1、玩家2轮流点击空白网格格子落子，各自的棋子有明确区分标识；
+     ② 已落子的格子无法重复点击，点击无响应；
+   - 胜利判定：
+     ① 任意一方的棋子在网格中连成横、竖、斜向的5子一线，立即判定该玩家获胜，禁用所有落子操作，提示区显示“X玩家获胜！”；
+     ② 网格全部落满且无5子连线，判定平局，提示区显示“平局！”。
+3. 基础玩法：
+   1. 游戏初始化后，提示区显示“游戏开始！玩家1先落子”；
+   2. 两位玩家交替点击空白格子落子，率先将5颗棋子连成一线的玩家获胜；
+   3. 游戏获胜/平局后，点击“重新开始”可清空所有棋子，重置游戏状态，重新开始对弈。
+请基于上述要求编写完整HTML代码
+```
+**代码生成效果**
+<div align="center">
+    <img src="./Demo/五子棋.gif" width="50%" alt="五子棋演示">
+    <p>👉点击体验 <a href="./Demo/五子棋.html">五子棋</a></p>
+</div>
+# 推理
+### Tranformers 推理
+TeleCoder3 模型支持使用 `transformers` 库进行推理，示例如下：
+```python
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+tokenizer = AutoTokenizer.from_pretrained('./TeleCoder3-36B-Thinking', trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained('./TeleCoder3-36B-Thinking', trust_remote_code=True, device_map="auto",torch_dtype=torch.bfloat16)
+prompt = "生抽与老抽的区别？"
+messages = [{"role": "user", "content": prompt}]
+text = tokenizer.apply_chat_template(messages,
+    tokenize=False,
+    add_generation_prompt=True
+)
+model_inputs = tokenizer(text, return_tensors="pt").to(model.device)
+generated_ids = model.generate(
+    **model_inputs,
+    top_p=0.95,
+    temperature=0.6,
+    repetition_penalty=1.0,
+    max_new_tokens=16384
+)
+response = tokenizer.decode(generated_ids[0], skip_special_tokens=False,spaces_between_special_tokens=False)
+answer = response.split("</think>")[-1].strip()
+```
+### VLLM 推理
+为适配 Interleaved Thinking 推理范式，我们基于 TeleChat3 系列模型重新设计了 Chat Template 及 Tool Call 的拼接方式。因此，在对 TeleCoder3 模型��行推理部署时，请首先参考 [TeleCoder3 vllm 补丁](TeleCoder3_vllm_tool_parser/README.md) 进行 vllm 配置，vllm 版本推荐使用0.9.2。
+然后，执行以下命令进行模型部署：
+```shell
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+python3 -m vllm.entrypoints.openai.api_server \
+        --model TeleCoder3-36B-Thinking  \
+        --trust-remote-code \
+        --tensor-parallel-size 8 \
+        --dtype bfloat16 \
+        --port 8000 \
+        --gpu-memory-utilization 0.9 \
+        --uvicorn-log-level "error" \
+        --max-model-len 131072 \
+        --enable-reasoning \
+        --enable-auto-tool-choice \
+        --tool-call-parser telechat3 \
+        --reasoning-parser deepseek_r1 \
+        --disable-custom-all-reduce \
+        --chat-template-content-format string
+```
+然后，您可以与 TeleCoder3 进行对话：
+```python
+from openai import OpenAI
+openai_api_key = "EMPTY"
+openai_api_base = "http://localhost:8000/v1"
+client = OpenAI(api_key=openai_api_key, base_url=openai_api_base)
+chat_response = client.chat.completions.create(
+    model="TeleCoder3-36B-Thinking",
+    messages=[
+        {"role": "user", "content": "生抽和酱油的区别是什么？"},
+    ],
+    temperature=0.6,
+    top_p=0.95,
+    max_tokens=16384,
+    extra_body={
+        "repetition_penalty": 1.0,
+        "skip_special_tokens": False,
+        "spaces_between_special_tokens": False,
+    },
+)
+print("Chat response:", chat_response)
+```
+**注意：** `skip_special_tokens`和`spaces_between_special_tokens`参数必须设置为 False，否则将无法正常解析推理结果
+### 推理参数选择
+- 在推理**代码任务**时，建议使用`repetition_penalty=1.0, top_p=0.95`, `temperature`设为`0.8-1.0`之间的值进行推理。
+- 在推理 **Agent 任务**时，建议使用`repetition_penalty=1.0, temperature=0.6, top_p=0.95`进行推理。
+# 国产化适配
+### 昇腾 Atlas 800T A2 训练服务器实现训练、推理适配
+#### 核心组件：
+- 昇思 MindSpore：该框架是华为开发的深度学习框架，旨在为AI应用提供高效、灵活的开发环境。它支持多种硬件平台，并具有自动微分、模型优化等功能，适合各种深度学习任务。
+- MindSpore Transformers：该框架的目标是构建一个大模型训练、微调、评估、推理、部署的全流程开发套件，提供业内主流的 Transformer 类预训练模型和 SOTA 下游任务应用，涵盖丰富的并行特性。期望帮助用户轻松的实现大模型训练和创新研发。
+**当前星辰语义代码大模型 TeleCoder3 支持昇腾 Atlas 800T A2 训练服务器，可基于昇思 MindSpore 框架以及 MindSpore Transformers 框架进行模型训练和评测。如果您对 MindFormers 相关特性有疑问，也可以查看 [MindFormers官方代码和文档](https://gitee.com/mindspore/mindformers/tree/dev/)。**
+# 致谢
+在此，我们要向开源社区的伟大贡献致以最深切的谢意——正是站在这些巨人的肩膀上，我们才得以眺望更远的风景。
+特别的向 DeepSeek 团队表达我们诚挚的感激。借鉴其模型架构的设计智慧，为我们模型的训练过程赋予了显著的稳定性与效率，使探索之路更为平稳而清晰。
+# 声明、协议、引用
+### 声明
+我们在此声明，不要使用 TeleCoder 模型及其衍生模型进行任何危害国家社会安全或违法的活动。同时，我们也要求使用者不要将 TeleCoder 模型用于没有安全审查和备案的互联网服务。我们希望所有使用者遵守上述原则，确保科技发展在合法合规的环境下进行。
+我们已经尽我们所能，来确保模型训练过程中使用的数据的合规性。然而，尽管我们已经做出了巨大的努力，但由于模型和数据的复杂性，仍有可能存在一些无法预见的问题。因此，如果由于使用 TeleCoder 开源模型而导致的任何问题，包括但不限于数据安全问题、公共舆论风险，或模型被误导、滥用、传播或不当利用所带来的任何风险和问题，我们将不承担任何责任。
+### 引用
+如需引用我们的工作，请使用如下 reference:
+```
+@misc{liu2025trainingreporttelechat3moe,
+      title={Training Report of TeleChat3-MoE},
+      author={Xinzhang Liu and Chao Wang and Zhihao Yang and Zhuo Jiang and Xuncheng Zhao and Haoran Wang and Lei Li and Dongdong He and Luobin Liu and Kaizhe Yuan and Han Gao and Zihan Wang and Yitong Yao and Sishi Xiong and Wenmin Deng and Haowei He and Kaidong Yu and Yu Zhao and Ruiyu Fang and Yuhao Jiang and Yingyan Li and Xiaohui Hu and Xi Yu and Jingqi Li and Yanwei Liu and Qingli Li and Xinyu Shi and Junhao Niu and Chengnuo Huang and Yao Xiao and Ruiwen Wang and Fengkai Li and Luwen Pu and Kaipeng Jia and Fubei Yao and Yuyao Huang and Xuewei He and Zhuoru Jiang and Ruiting Song and Rui Xue and Qiyi Xie and Jie Zhang and Zilu Huang and Zhaoxi Zhang and Zhilong Lu and Yanhan Zhang and Yin Zhang and Yanlei Xue and Zhu Yuan and Teng Su and Xin Jiang and Shuangyong Song and Yongxiang Li and Xuelong Li},
+      year={2025},
+      eprint={2512.24157},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2512.24157},
+}
+@misc{wang2025technicalreporttelechat2telechat25,
+      title={Technical Report of TeleChat2, TeleChat2.5 and T1},
+      author={Zihan Wang and Xinzhang Liu and Yitong Yao and Chao Wang and Yu Zhao and Zhihao Yang and Wenmin Deng and Kaipeng Jia and Jiaxin Peng and Yuyao Huang and Sishi Xiong and Zhuo Jiang and Kaidong Yu and Xiaohui Hu and Fubei Yao and Ruiyu Fang and Zhuoru Jiang and Ruiting Song and Qiyi Xie and Rui Xue and Xuewei He and Yanlei Xue and Zhu Yuan and Zhaoxi Zhang and Zilu Huang and Shiquan Wang and Xin Wang and Hanming Wu and Mingyuan Wang and Xufeng Zhan and Yuhan Sun and Zhaohu Xing and Yuhao Jiang and Bingkai Yang and Shuangyong Song and Yongxiang Li and Zhongjiang He and Xuelong Li},
+      year={2025},
+      eprint={2507.18013},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2507.18013},
+}
+```

TeleCoder3_vllm_tool_parser/.gitignore ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ __pycache__/
2	+ *.egg-info/

TeleCoder3_vllm_tool_parser/README.md ADDED Viewed

	@@ -0,0 +1,12 @@

+### 针对 VLLM 框架的 TeleCoder3 模型补丁
+#### 目前支持以下功能
+- 工具调用解析
+- 支持 Interleaved Thinking 模式：chat 接口的 message 支持 reasoning_content 字段，并拼接到 模型上下文中
+#### 使用教程
+1. 安装插件（只需要执行一次）
+```shell
+pip install -e .
+```
+2. 如果需要工具解析，启动vllm服务的时候加上参数`--enable-auto-tool-choice --tool-call-parser telechat3`

TeleCoder3_vllm_tool_parser/setup.py ADDED Viewed

	@@ -0,0 +1,15 @@

+from setuptools import setup, find_packages
+setup(
+    name="telechat3_vllm_patch",
+    version="1.1.0",
+    packages=find_packages(
+        include=["telechat3_tool_parser.py", "telechat3_reasoning.py"]
+    ),
+    entry_points={
+        "vllm.general_plugins": [
+            "telechat3_tool_parser = telechat3_tool_parser:register_tool_parser",
+            "telechat3_reasoning = telechat3_reasoning:register_reasoning",
+        ]
+    },
+)

TeleCoder3_vllm_tool_parser/telechat3_reasoning.py ADDED Viewed

	@@ -0,0 +1,32 @@

+import vllm
+from vllm.entrypoints.chat_utils import (
+    ChatCompletionMessageParam,
+    ConversationMessage,
+    BaseMultiModalItemTracker,
+    _ChatTemplateContentFormat,
+    _parse_chat_message_content,
+)
+from vllm.logger import init_logger
+logger = init_logger(__name__)
+def _telechat3_parse_chat_message_content(
+    message: ChatCompletionMessageParam,
+    mm_tracker: BaseMultiModalItemTracker,
+    content_format: _ChatTemplateContentFormat,
+) -> list[ConversationMessage]:
+    result = _parse_chat_message_content(message, mm_tracker, content_format)
+    reasoning_content = message.get("reasoning_content")
+    if len(result) > 0 and reasoning_content:
+        logger.info("add reasoning content to input prompt.")
+        result[0].update({"reasoning_content": reasoning_content})
+    return result
+def register_reasoning():
+    vllm.entrypoints.chat_utils._parse_chat_message_content = (
+        _telechat3_parse_chat_message_content
+    )

TeleCoder3_vllm_tool_parser/telechat3_tool_parser.py ADDED Viewed

	@@ -0,0 +1,175 @@

+import ast
+import json
+import regex as re
+from collections.abc import Sequence
+from typing import List, Any
+from transformers import PreTrainedTokenizerBase
+from vllm.entrypoints.openai.protocol import (
+    ChatCompletionRequest,
+    ChatCompletionToolsParam,
+    DeltaFunctionCall,
+    DeltaMessage,
+    DeltaToolCall,
+    ExtractedToolCallInformation,
+    FunctionCall,
+    ToolCall,
+)
+from vllm.entrypoints.openai.tool_parsers.abstract_tool_parser import (
+    ToolParser,
+    ToolParserManager,
+)
+from vllm.logger import init_logger
+logger = init_logger(__name__)
+def _is_string_type(
+    tool_name: str, arg_name: str, tools: List[ChatCompletionToolsParam] | None
+):
+    if tools is None:
+        return False
+    for tool in tools:
+        if tool.function.name == tool_name:
+            if tool.function.parameters is None:
+                return False
+            arg_type = (
+                tool.function.parameters.get("properties", {})
+                .get(arg_name, {})
+                .get("type", None)
+            )
+            return arg_type == "string"
+    logger.debug("No tool named '%s'.", tool_name)
+    return False
+def _deserialize(value: str) -> Any:
+    try:
+        return json.loads(value)
+    except Exception:
+        pass
+    try:
+        return ast.literal_eval(value)
+    except Exception:
+        pass
+    return value
+@ToolParserManager.register_module("telechat3")
+class TeleChat3ModelToolParser(ToolParser):
+    """
+    Tool call parser for TeleChat3-36B models.
+    Used when --enable-auto-tool-choice --tool-call-parser telechat3
+    """
+    def __init__(self, tokenizer: PreTrainedTokenizerBase):
+        super().__init__(tokenizer)
+        # initialize properties used for state when parsing tool calls in
+        # streaming mode
+        self.current_tool_id: int = -1
+        self.tool_start_token = "<tool_call>"
+        self.tool_end_token = "</tool_call>"
+        self.func_detail_regex = re.compile(
+            r"<tool_call>(.*?)(<param_key>.*?)?</tool_call>", re.DOTALL
+        )
+        self.func_arg_regex = re.compile(
+            r"<param_key>(.*?)</param_key>(?:\\n|\s)*<param_value>(.*?)</param_value>",
+            re.DOTALL,
+        )
+        self._buffer = ""
+    def extract_tool_calls(self, model_output: str, request: ChatCompletionRequest):
+        matched_tool_calls = self.func_detail_regex.findall(model_output)
+        logger.debug("model_output: %s", model_output)
+        tool_calls = []
+        try:
+            for match in matched_tool_calls:
+                tc_name = match[0].strip()
+                arg_dict = {}
+                if len(match) > 1:
+                    for key, value in self.func_arg_regex.findall(match[1]):
+                        arg_key = key.strip()
+                        arg_val = value.strip()
+                        if not _is_string_type(tc_name, key, request.tools):
+                            arg_val = _deserialize(arg_val)
+                        logger.debug("arg_key = %s, arg_val = %s", arg_key, arg_val)
+                        arg_dict[arg_key] = arg_val
+                tool_calls.append(
+                    ToolCall(
+                        type="function",
+                        function=FunctionCall(
+                            name=tc_name,
+                            arguments=json.dumps(arg_dict, ensure_ascii=False),
+                        ),
+                    )
+                )
+        except Exception:
+            logger.exception("Failed to extract tool call spec")
+            return ExtractedToolCallInformation(
+                tools_called=False, tool_calls=[], content=model_output
+            )
+        else:
+            if len(tool_calls) > 0:
+                content = model_output[: model_output.find(self.tool_start_token)]
+                return ExtractedToolCallInformation(
+                    tools_called=True, tool_calls=tool_calls, content=content
+                )
+            return ExtractedToolCallInformation(
+                tools_called=False, tool_calls=[], content=model_output
+            )
+    def extract_tool_calls_streaming(
+        self,
+        previous_text: str,
+        current_text: str,
+        delta_text: str,
+        previous_token_ids: Sequence[int],
+        current_token_ids: Sequence[int],
+        delta_token_ids: Sequence[int],
+        request: ChatCompletionRequest,
+    ) -> DeltaMessage | None:
+        self._buffer += delta_text
+        cur_text = self._buffer
+        start_idx = cur_text.find(self.tool_start_token)
+        if start_idx == -1:
+            self._buffer = ""
+            return DeltaMessage(content=cur_text)
+        logger.debug("cur_text = %s", cur_text)
+        end_idx = cur_text.find(self.tool_end_token)
+        if end_idx != -1:
+            extracted_tool_calls = self.extract_tool_calls(
+                cur_text[: end_idx + len(self.tool_end_token)], request
+            )
+            if len(extracted_tool_calls.tool_calls) == 0:
+                logger.warning("Failed to extract any tool calls.")
+                return None
+            self.current_tool_id += 1
+            tool_call = extracted_tool_calls.tool_calls[0]
+            delta = DeltaMessage(
+                content=extracted_tool_calls.content,
+                tool_calls=[
+                    DeltaToolCall(
+                        index=self.current_tool_id,
+                        id=tool_call.id,
+                        type=tool_call.type,
+                        function=DeltaFunctionCall(
+                            name=tool_call.function.name,
+                            arguments=tool_call.function.arguments,
+                        ),
+                    )
+                ],
+            )
+            self._buffer = cur_text[end_idx + len(self.tool_end_token) :]
+            return delta
+        self._buffer = cur_text[start_idx:]
+        return DeltaMessage(content=cur_text[:start_idx])
+def register_tool_parser(): ...

images/TeleCoder3_post_training.png ADDED Viewed