#navbar button[aria-haspopup="menu"] {
  display: none;
}

.table-container {
  overflow-x: scroll;
  box-shadow: 3px 0 10px 0 rgba(25, 85, 140, .05);
}

.table-container table {
  margin-top: 0;
}

.table thead {
  background-color: #eef2f150;
}

.table thead th {
  padding: 8px 10px;
  text-align: left;
  white-space: nowrap;
}

.table tbody td {
  padding: 6px 10px;
}

.table-big thead th {
  padding: 12px 10px;
}

.table-big tbody td {
  padding: 10px 10px;
}

.table .list-col {
  position: relative;
  padding-left: 31px;
  margin: 0;
  text-align: left;
}

.table .list-col::before {
  content: "•";
  position: absolute;
  left: 18px;
  top: 6px;
  color: #16b063b0;
}

.table .list-sub-col {
  position: relative;
  padding-left: 46px;
  margin: 0;
  text-align: left;
}

.table .list-sub-col::before {
  content: "";
  position: absolute;
  left: 36px;
  top: 15px;
  width: 4px;
  height: 4px;
  background-color: #16b06380;
}

.table .list-grandson-col {
  position: relative;
  padding-left: 60px;
  margin: 0;
  text-align: left;
}
  
.table .list-grandson-col::before {
  content: "";
  position: absolute;
  left: 50px;
  top: 15px;
  width: 4px;
  height: 4px;
  border-radius: 100%;
  border: 1px solid #16b06380;
}

.table .list-grandson-sub-col {
  position: relative;
  padding-left: 66px;
  margin: 0;
  text-align: left;
}
  
.table .list-grandson-sub-col::before {
  content: "";
  position: absolute;
  left: 58px;
  top: 16px;
  width: 3px;
  height: 3px;
  border-radius: 100%;
  border: 1px solid #16b06350;
}

.table .type-desc {
  display: inline-block;
  margin-left: 12px;
  color: #9e9c98b0;
}

.table .type-desc-narrow {
  margin-left: 4px;
}

.table .delete {
  text-decoration: line-through;
}

.table .deprecated {
  display: inline-block;
  color: #f23030;
  margin-bottom: 4px;
}

.table .new-field {
  display: inline-block;
  margin-bottom: 4px;
  color: #22ad5c;
}

.table .moved {
  display: inline-block;
  margin-bottom: 4px;
  color: #f27430;
}  

.table .inline-block {
  display: inline-block;
}

.table .mt-1 {
  margin-top: 4px;
}

.table .mt-2 {
  margin-top: 8px;
}

.table .ml-0 {
  margin-left: 0;
}



#assistant-entry {
  display: none !important;
}
#chat-assistant-sheet {
  display: none !important;
}
#content-side-layout.invisible {
  visibility: visible !important;
}

#!/usr/bin/env node

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

/**
 * 脚本：重构 mdx 文件中的图片路径
 * 
 * 用法: node restructure-images.js <mdx-file-path>
 * 例如: node restructure-images.js third-party/langbot-use.mdx
 */

function main() {
  // 获取命令行参数
  const args = process.argv.slice(2);
  if (args.length !== 1) {
    console.error('用法: node restructure-images.js <mdx-file-path>');
    console.error('例如: node restructure-images.js third-party/langbot-use.mdx');
    process.exit(1);
  }

  const mdxFilePath = args[0];

  // 验证输入文件
  if (!mdxFilePath.startsWith('third-party/') || !mdxFilePath.endsWith('.mdx')) {
    console.error('错误: 必须是 third-party 目录下的 .mdx 文件');
    process.exit(1);
  }

  if (!fs.existsSync(mdxFilePath)) {
    console.error(`错误: 文件不存在: ${mdxFilePath}`);
    process.exit(1);
  }

  // 检查项目根目录下是否有 images 目录
  const rootImagesDir = 'images';
  if (!fs.existsSync(rootImagesDir)) {
    console.log('项目根目录下没有 images 目录，退出。');
    // return;
  }

  // 获取 appName
  const fileName = path.basename(mdxFilePath, '.mdx');
  const appName = fileName.endsWith('-use') ? fileName.slice(0, -4) : fileName;
  
  console.log(`处理文件: ${mdxFilePath}`);
  console.log(`应用名称: ${appName}`);

  // 创建目标目录
  const targetDir = path.join('third-party/images', appName);
  if (!fs.existsSync('third-party/images')) {
    fs.mkdirSync('third-party/images', { recursive: true });
  }
  if (!fs.existsSync(targetDir)) {
    fs.mkdirSync(targetDir, { recursive: true });
    console.log(`创建目录: ${targetDir}`);
  }

  // 移动文件
  moveFilesRecursively(rootImagesDir, targetDir);

  // 编辑 mdx 文件
  updateMdxFile(mdxFilePath, appName);

  console.log('处理完成！');
}

/**
 * 递归移动文件
 */
function moveFilesRecursively(sourceDir, targetDir) {
  if (!fs.existsSync(sourceDir)) {
    return;
  }

  const items = fs.readdirSync(sourceDir);
  
  for (const item of items) {
    const sourcePath = path.join(sourceDir, item);
    const targetPath = path.join(targetDir, item);
    
    const stat = fs.statSync(sourcePath);
    
    if (stat.isDirectory()) {
      // 如果是目录，递归处理
      if (!fs.existsSync(targetPath)) {
        fs.mkdirSync(targetPath, { recursive: true });
      }
      moveFilesRecursively(sourcePath, targetPath);
      
      // 检查源目录是否为空，如果为空则删除
      const remainingItems = fs.readdirSync(sourcePath);
      if (remainingItems.length === 0) {
        fs.rmdirSync(sourcePath);
        console.log(`删除空目录: ${sourcePath}`);
      }
    } else {
      // 如果是文件，移动文件
      fs.renameSync(sourcePath, targetPath);
      console.log(`移动文件: ${sourcePath} -> ${targetPath}`);
    }
  }

  // 检查根源目录是否为空，如果为空则删除
  try {
    const remainingItems = fs.readdirSync(sourceDir);
    if (remainingItems.length === 0) {
      fs.rmdirSync(sourceDir);
      console.log(`删除空目录: ${sourceDir}`);
    }
  } catch (error) {
    // 目录可能已经被删除
  }
}

/**
 * 更新 mdx 文件中的路径
 */
function updateMdxFile(filePath, appName) {
  let content = fs.readFileSync(filePath, 'utf8');
  
  // 记录替换次数
  let replacements = 0;
  
  // 替换 (/images/ 为 (./images/${appName}/
  const pattern1 = /\(\/images\//g;
  const replacement1 = `(./images/${appName}/`;
  const matches1 = content.match(pattern1);
  if (matches1) {
    replacements += matches1.length;
    content = content.replace(pattern1, replacement1);
  }
  
  // 替换 src="/images/ 为 src="./images/${appName}/
  const pattern2 = /src="\/images\//g;
  const replacement2 = `src="./images/${appName}/`;
  const matches2 = content.match(pattern2);
  if (matches2) {
    replacements += matches2.length;
    content = content.replace(pattern2, replacement2);
  }
  
  // 写回文件
  fs.writeFileSync(filePath, content, 'utf8');
  
  console.log(`更新 ${filePath}，共进行了 ${replacements} 次路径替换`);
}

// 执行主函数
if (import.meta.url === `file://${process.argv[1]}`) {
  try {
    main();
  } catch (error) {
    console.error('错误:', error.message);
    process.exit(1);
  }
} 

// 监听 DOM 变化，移除 chat-assistant-sheet 元素及其父元素
(function() {
  // 创建 MutationObserver 实例
  const observer = new MutationObserver(function(mutations) {
    mutations.forEach(function(mutation) {
      // 检查新增的节点
      mutation.addedNodes.forEach(function(node) {
        // 确保是元素节点
        if (node.nodeType === Node.ELEMENT_NODE) {
          // 检查当前节点是否为目标元素
          if (node.id === 'chat-assistant-sheet') {
            removeChatAssistant(node);
            return;
          }
          
          // 检查子节点中是否包含目标元素
          const targetElement = node.querySelector && node.querySelector('#chat-assistant-sheet');
          if (targetElement) {
            removeChatAssistant(targetElement);
          }
        }
      });
    });
  });
  
  // 移除 chat-assistant-sheet 元素的父元素
  function removeChatAssistant(element) {
    try {
      const parentElement = element.parentElement;
      if (parentElement) {
        console.log('Removing chat assistant element and its parent');
        parentElement.remove();
      }
    } catch (error) {
      console.error('Error removing chat assistant element:', error);
    }
  }
  
  // 检查页面加载时是否已存在目标元素
  function checkExistingElements() {
    const existingElement = document.getElementById('chat-assistant-sheet');
    if (existingElement) {
      removeChatAssistant(existingElement);
    }
  }
  
  // 开始观察 DOM 变化
  function startObserving() {
    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  }
  
  // 页面加载完成后执行
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', function() {
      checkExistingElements();
      startObserving();
    });
  } else {
    checkExistingElements();
    startObserving();
  }
})();


/**
 * Forbidden Keywords Check Script
 *
 * This script searches for forbidden keywords in the codebase that should not be committed.
 * It is designed to be run as part of the git pre-commit hook to prevent committing
 * unwanted keywords.
 *
 * Usage:
 *   - Run manually: npm run zh-check
 *   - Automatically runs during git commit via the pre-commit hook
 *
 * Exit codes:
 *   - 0: Success, no forbidden keywords found
 *   - 1: Error, forbidden keywords found or script execution failed
 */

import fs from "fs";
import path from "path";

const FORBIDDEN_KEYWORDS = [
  "novita",
  "discord",
  "linkedin",
  "instagram",
  "facebook",
  "tiktok",
  "youtube",
  "twitter",
  "mintlify",
  "llama",
  "Llama",
  "LLAMA",
  "gemma",
];

const WHITELIST_KEYWORDS = [
  `"$schema": "https://mintlify.com/docs.json"`,
];

const SRC_DIR = "./";
const SKIP_PATHS = [
  "script",
  ".git",
  ".github",
  "node_modules",
  "dist",
  "build",
  "logs",
  "temp",
  "tmp",
  "package.json",
  "package-lock.json",
  ".mintlify",
  "development.mdx",
  "README.md",
];

/**
 * Determines if a file or line should be ignored during the check
 * @param {string} filePath - Path to the file being checked
 * @param {string} line - Current line content being checked
 * @returns {boolean} - True if the line should be ignored, false otherwise
 */
function shouldIgnore(filePath, line) {
  const relativePath = path.relative(process.cwd(), filePath);
  // Ignore image files
  if (/\.(jpg|jpeg|png|gif|svg|ico|webp)$/i.test(relativePath)) {
    return true;
  }
  if (SKIP_PATHS.some((dir) => relativePath.startsWith(dir))) {
    return true;
  }
  if (
    relativePath.startsWith("src/app/model-api/playground/sample-codes") &&
    line.includes(`code = code.replace(/novita.ai/g, "ppinfra.com");`)
  ) {
    return true;
  }
  if (
    relativePath.startsWith("src/api/api.ts") &&
    (line.includes("NovitaSDK") || line.includes("NovitaError"))
  ) {
    return true;
  }
  if (WHITELIST_KEYWORDS.some((keyword) => line.includes(keyword))) {
    return true;
  }
  return false;
}

/**
 * Recursively searches files in a directory for forbidden keywords
 * @param {string} dir - Directory to search
 * @param {string[]} keywords - List of keywords to search for
 * @returns {Array} - Array of matches found
 */
function searchFiles(dir, keywords) {
  const results = [];

  function searchInFile(filePath) {
    try {
      const content = fs.readFileSync(filePath, "utf8");
      const lines = content.split("\n");

      lines.forEach((line, index) => {
        if (shouldIgnore(filePath, line)) {
          return;
        }
        keywords.forEach((keyword) => {
          if (line.toLowerCase().includes(keyword.toLowerCase())) {
            results.push({
              file: path.relative(process.cwd(), filePath),
              line: index + 1,
              keyword: keyword,
              content: line.trim(),
            });
          }
        });
      });
    } catch (error) {
      console.error(`Failed to read file: ${filePath}`, error);
    }
  }

  function walkDir(currentDir) {
    const files = fs.readdirSync(currentDir);

    files.forEach((file) => {
      const filePath = path.join(currentDir, file);
      const stat = fs.statSync(filePath);

      if (stat.isDirectory()) {
        walkDir(filePath);
      } else if (stat.isFile()) {
        searchInFile(filePath);
      }
    });
  }

  walkDir(dir);
  return results;
}

try {
  console.log(
    `Starting to check forbidden keywords: ${FORBIDDEN_KEYWORDS.join(
      ", ",
    )} in directory ${SRC_DIR}`,
  );

  const matches = searchFiles(SRC_DIR, FORBIDDEN_KEYWORDS);

  const totalMatches = [...matches];
  const uniqueMatches = totalMatches.filter(
    (match, index, self) =>
      index ===
      self.findIndex((m) => m.file === match.file && m.line === match.line),
  );

  if (uniqueMatches.length > 0) {
    console.error("\nForbidden keywords found in following locations:\n");
    uniqueMatches.forEach((match) => {
      console.error(`\x1b[31mFile: ${match.file}\x1b[0m`);
      console.error(`Line: ${match.line}`);
      console.error(`Keyword: ${match.keyword}`);
      console.error(`Content: ${match.content}`);
      console.error("\n");
    });
    console.error(`\x1b[31mTotal matches: ${uniqueMatches.length}\x1b[0m`);
    process.exit(1);
  } else {
    console.log("Check passed: No forbidden keywords found");
    process.exit(0);
  }
} catch (error) {
  console.error("Error occurred during check:", error);
  process.exit(1);
}


产品简介

计费说明

操作指南

常见问题

Serverless GPUs

功能特性

产品架构

产品计费

产品使用

产品简介

计费说明

操作指南

常见问题

​功能特性

​产品架构

​产品计费

​产品使用

功能特性

产品架构

产品计费

产品使用