DeepSeek Harness为什么使用TypeScript ?前端语言,为什么适合做 Agent?

大家好,我是 WeiWill,深耕软件工程一线,专注 AI 应用落地与 Agent 开发。

DeepSeek AI 开源的 DeepSeek Harness,一个用来运行和扩展 Agent 的 harness,核心设计是“Everything is a Plugin”。

看仓库里的构建脚本和 CLI 入口,会发现 TypeScript 负责主要的应用代码。

这就把一个常见疑问摆到了台面上:Agent 明明不是传统意义上的前端项目,为什么越来越多地使用 TypeScript?

很多人的第一反应是:

JavaScript 和 TypeScript 不就是前端脚本语言吗?为什么现在开始负责 Agent、工具调用和后端工作流了?

过去我们提到 JavaScript,想到的可能是浏览器里的按钮、表单校验和页面动画。可是现在的 Agent,真正要做的事情通常是:调用大模型接口,读取文件,访问数据库,连接 MCP,执行工具,等待队列和 webhook,再通过网页、桌面端或聊天窗口把结果流式返回。

这类系统的难点,不只是“把代码算出来”,而是要长期处理大量外部等待、异步状态和系统连接。

所以,越来越多 Agent 使用 TypeScript,核心原因可以先概括成一句话:

TypeScript 借助 Node.js,把前端世界的 JavaScript 延伸成了一套非常适合连接用户、模型、工具和业务系统的运行层。

思维导图

思维导图

先说结论:大家看中的是连接层

一个可用的 Agent,通常不是单独调用一次模型就结束了。它更像一个持续运行的工作流:

  1. 接收用户请求;
  2. 调用模型判断下一步动作;
  3. 读取上下文或业务数据;
  4. 调用一个或多个工具;
  5. 等待外部系统返回;
  6. 根据结果继续推理或重试;
  7. 把中间状态和最终答案返回给用户。

这条链路里,真正占时间的部分,往往是等待,而不是计算。模型接口要等待,数据库要等待,文件系统要等待,远程服务要等待,浏览器自动化和人工确认也要等待。

因此,Agent 的产品层和编排层首先需要解决的是三个问题:

  • 能不能同时管理很多外部调用;
  • 能不能把异步结果按顺序合并回任务;
  • 能不能让工具参数、任务状态和接口响应保持清晰。

Node.js 擅长前两个问题,TypeScript 主要加强第三个问题。两者放在一起,才是 Agent 项目经常选择它们的原因。

这并不等于 TypeScript 适合所有 Agent。它更适合的是模型调用、工具编排、服务接口、流式输出和产品集成这一层。

JavaScript 明明是前端语言,为什么能做后端

这里需要先把三个概念分开:语言、运行时和应用框架。

JavaScript 是一门语言。浏览器是 JavaScript 的一个运行时,Node.js 是另一个运行时。React、Vue、Express、NestJS 等,则是建立在运行时之上的库或框架。

浏览器里的 JavaScript 受到浏览器安全模型限制,主要操作页面、网络请求和用户交互。Node.js 没有页面,但它提供了服务器程序需要的能力,例如:

  • 读取文件和目录;
  • 创建 HTTP 服务和发起网络请求;
  • 访问数据库、消息队列和缓存;
  • 处理进程、环境变量和子进程;
  • 使用流、WebSocket、SSE 等方式传输数据。

所以,“JavaScript 是前端语言”只描述了它最早被广泛使用的场景,并没有限定它只能运行在浏览器里。

这就像 Java 既可以写桌面程序,也可以写后端服务;语言本身和它所在的运行环境不是一回事。JavaScript 在浏览器里是一种交互语言,在 Node.js 里则可以成为服务端程序的实现语言。

Node.js 的出现,让前端工程师使用熟悉的语言进入服务端开发,也让用户界面、后端接口和实时通信可以共享一套类型与数据模型。对于 Agent 来说,这种连接非常直接:用户在页面上发起任务,Node.js 接收请求,调用模型和工具,再把过程实时推回页面。

TypeScript 和 Node.js 到底是什么关系

TypeScript 不是 Node.js 的替代品,也不是一个独立的服务器运行时。

TypeScript 是 JavaScript 的超集。它在 JavaScript 的基础上增加了类型标注、接口、泛型、联合类型、枚举等开发期能力。Node.js 最终执行的仍然是 JavaScript。

一个最简单的运行链路是:

1
2
3
4
5
6
7
8
9
src/index.ts
│
│ TypeScript 编译器 tsc
▼
dist/index.js
│
│ Node.js 运行时
▼
程序开始执行

例如,源文件可以这样写:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type UserRequest = {
userId: string;
prompt: string;
};

async function handleRequest(request: UserRequest) {
const response = await fetch("https://example.com/agent", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(request),
});

return response.json();
}

开发阶段,工具可以直接把 .ts 文件转换后执行,例如:

1
2
npx tsc
node dist/index.js

也可以使用 tsx 这类开发工具直接运行 TypeScript:

1
npx tsx src/index.ts

这两种方式的本质没有变化:TypeScript 负责在开发阶段提供类型检查和转换,Node.js 负责提供运行时能力并执行最终的 JavaScript。

这点很重要。很多人说“Node.js 运行 TypeScript”,严格来说并不准确。更准确的表达是:TypeScript 代码经过转换后由 Node.js 执行,开发工具把转换过程隐藏了。

在生产环境里,通常会先执行 tsc,把源文件放进 dist 目录,再由 Node.js 启动编译后的 JavaScript。这样可以把类型检查、构建和运行拆开,问题更容易定位:编译失败是代码契约问题,运行失败才是环境、数据或业务逻辑问题。

Node.js 为什么适合大量 I/O 和异步调用

这才是 Agent 选择 TypeScript 生态时最关键的技术背景。

Agent 的大部分时间在等待

假设一个 Agent 要完成“查询客户资料并生成处理建议”:

  1. 调用模型理解用户问题;
  2. 查询客户数据库;
  3. 调用订单系统;
  4. 查询知识库;
  5. 把多个结果交给模型总结;
  6. 通过 SSE 把过程推送给前端。

这些步骤会产生多次网络等待。程序发出请求之后,CPU 并不需要一直盯着网络连接。更理想的方式是:发起 I/O,暂时交出执行权,等结果回来后再继续处理。

Node.js 的核心模型就是事件循环。JavaScript 代码通常在一个主线程上执行;文件、网络、定时器等异步工作由操作系统和 Node.js 底层机制处理;当结果准备好之后,事件循环再把对应的回调或 Promise 继续调度回来。

可以把它理解成餐厅前台:前台负责接单和分发,不会因为一桌客人在等菜,就站在厨房门口一直等。厨房完成后通知前台,前台再继续处理下一步。

这个模型特别适合 Agent,因为 Agent 同时面对的通常不是一个慢任务,而是很多彼此独立的外部任务:模型 API、MCP 服务、数据库、文件读取、HTTP 接口和消息队列。

async/await 让异步流程保持可读

早期 JavaScript 的异步代码容易出现多层回调。现在的 JavaScript 和 TypeScript 通常使用 Promise 和 async/await,让异步流程看起来接近普通的顺序代码:

1
2
3
4
5
async function buildAnswer(prompt: string) {
const modelResult = await callModel(prompt);
const toolResult = await runTool(modelResult.toolCall);
return callModelWithToolResult(modelResult, toolResult);
}

这里的 await 不代表整个 Node.js 进程被阻塞。它只是暂停当前函数,把执行权交给事件循环。其他请求、定时器或已经完成的异步任务,仍然可以继续推进。

如果几个工具之间没有依赖关系,还可以并发发起:

1
2
3
4
5
const [customer, orders, knowledge] = await Promise.all([
loadCustomer(customerId),
loadOrders(customerId),
searchKnowledge(prompt),
]);

这段代码表达的是:三个查询可以同时开始,全部完成后再进入下一步。对 Agent 来说,这往往比一个查询结束后再发起下一个查询更节省时间。

当然,Promise.all 不是越多越好。需要考虑接口限流、数据库连接数、失败重试、超时和取消。如果一个任务失败会让整体结果失效,可以使用 Promise.all;如果允许部分成功,就需要记录每个调用的状态,不能简单地把所有异常混在一起。

异步不等于适合所有计算

Node.js 的优势在 I/O 等待,不在于把大量 CPU 计算塞到事件循环里。

如果 Agent 要做大规模图像处理、音频转码、复杂搜索、加密计算或本地模型推理,长时间运行的同步计算可能阻塞事件循环,让其他请求都无法及时响应。这时可以使用 Worker、子进程、任务队列,或者把计算核心交给 Rust、Java 等更适合的服务。

这也是工程判断的一部分:Node.js 适合负责“协调很多事情”,不一定适合负责“亲自计算所有事情”。

TypeScript 在 Agent 里真正解决了什么

Node.js 解决的是运行模型,TypeScript 解决的是代码规模变大之后的可控性。

让工具调用从字符串变成契约

Agent 最容易出问题的地方之一,就是工具调用的输入和输出。模型可能生成一个字段名,服务端期待另一个字段名;某个工具把数字返回成字符串;某个分支缺少必填参数。系统运行到这里才报错,排查成本很高。

TypeScript 可以先把工具接口表达出来:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type SearchInput = {
query: string;
limit?: number;
};

type SearchOutput = {
items: Array<{
title: string;
url: string;
content: string;
}>;
};

type Tool<Input, Output> = {
name: string;
run(input: Input): Promise<Output>;
};

const searchTool: Tool<SearchInput, SearchOutput> = {
name: "search",
async run(input) {
return searchKnowledge(input);
},
};

当工具实现和调用方不一致时,编辑器和编译器可以在提交代码前提示问题。它不能保证模型一定输出正确 JSON,但能保证我们写出来的调用代码不会悄悄假设一个错误的数据结构。

这里要区分两层校验:

  • TypeScript 类型是开发期检查,编译完成后会被移除;
  • 用户输入、模型输出和远程响应属于运行时数据,仍然需要使用 JSON Schema、Zod 等方式验证。

如果把这两层混为一谈,就会误以为“有 TypeScript 就不会有脏数据”。真正可靠的做法,是用 TypeScript 管理代码之间的契约,再用运行时校验守住外部边界。

让任务状态更容易扩展

一个 Agent 通常有很多状态:等待模型、等待工具、工具失败、需要重试、等待人工确认、已完成和已取消。如果这些状态只是字符串,随着功能增加,很容易出现分支遗漏。

TypeScript 可以使用联合类型表达状态:

1
2
3
4
5
6
type TaskState =
| { type: "waiting-model"; attempt: number }
| { type: "waiting-tool"; toolName: string }
| { type: "waiting-human"; reason: string }
| { type: "completed"; answer: string }
| { type: "failed"; message: string };

处理状态时,代码可以根据 type 自动收窄字段。以后新增状态,编译器会帮助我们找到还没有处理的地方。这一点对于 Agent 很实用,因为 Agent 的复杂度往往不是来自某一个函数,而是来自状态越来越多、分支越来越长。

让前后端共享同一套数据语言

Agent 产品一般需要一个交互界面:聊天窗口、任务列表、工具执行日志、审批页面或实时事件流。

如果前端和后端分别维护请求、响应和事件结构,字段很容易逐渐分叉。TypeScript 可以让前端、Node.js 服务、CLI 工具和部分 SDK 共享类型定义,至少让接口变更有明确的反馈。

例如,后端产生的事件可以定义成:

1
2
3
4
5
type AgentEvent =
| { type: "message"; content: string }
| { type: "tool-start"; name: string; input: unknown }
| { type: "tool-end"; name: string; durationMs: number }
| { type: "error"; message: string };

前端收到事件后,能根据 type 选择渲染方式;服务端增加事件类型时,相关处理代码会暴露出来。对需要持续输出中间过程的 Agent 来说,这比只返回一个最终字符串更容易维护。

一个 Agent 请求是怎么跑起来的

把前面的概念连在一起,可以看一个简化的请求流程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
浏览器 / CLI
│ 发送用户请求
▼
Node.js HTTP 服务
│
├─ 调用模型 API
│ │
│ └─ 返回工具调用意图
│
├─ 并发访问数据库、MCP、知识库
│
├─ 合并结果并继续调用模型
│
└─ 通过 SSE / WebSocket 推送事件
▼
用户看到过程和最终答案

这个流程中,TypeScript 负责描述请求、工具参数、任务状态和事件结构;Node.js 负责启动 HTTP 服务、发起异步 I/O、管理连接并把结果推回客户端。

如果只用 JavaScript,也可以实现同样的运行效果。TypeScript 的价值主要体现在项目变大之后:工具变多、开发者变多、接口变多、状态变复杂时,类型系统可以更早暴露错误,也让 IDE 和代码生成工具更容易理解项目结构。

这也是为什么 TypeScript 在 Agent 领域的优势不是“语法更漂亮”,而是它能把一条动态的调用链,逐步整理成可检查、可协作、可演进的工程代码。

TypeScript 和 Rust 怎么选

TypeScript 和 Rust 并不是简单的替代关系。它们更像是 Agent 系统中两个不同位置的选择。

对比维度 TypeScript + Node.js Rust
主要优势 快速连接模型、工具、接口和用户界面 性能、内存安全和可预测性
典型运行方式 JavaScript 运行时、事件循环、异步 I/O 编译成本地二进制、直接使用系统资源
更适合的层 产品层、服务层、工作流编排层 核心引擎、系统工具、沙箱和高性能模块
开发体验 迭代快,Web 生态和 SDK 丰富 约束强,编译器反馈深入,学习成本更高
主要风险 类型不等于运行时安全,CPU 任务会阻塞事件循环 开发和跨语言集成成本较高
常见选择 先把 Agent 工作流做出来并持续集成 对性能、资源、隔离和部署形态有硬要求

TypeScript 更适合连接外部世界

如果一个 Agent 的工作主要是:

  • 接收 HTTP 请求;
  • 调用多个模型和 SaaS API;
  • 连接 MCP、数据库、缓存和队列;
  • 处理流式响应;
  • 把状态展示给网页或桌面端;
  • 快速试验新的工具和工作流;

那么 TypeScript + Node.js 往往可以很快形成完整闭环。这里的关键指标不是单次计算速度,而是接入速度、异步流程的可读性和前后端协作成本。

Rust 更适合高约束的底层能力

如果 Agent 需要高性能文件索引、复杂解析、严格的资源控制、进程隔离、本地执行沙箱或长期运行的系统级服务,Rust 会更有优势。

例如,一个桌面 Agent 可以用 TypeScript 编写界面和任务编排,再使用 Rust 实现文件扫描、代码索引或安全执行模块。这样做的好处是,每种语言负责自己擅长的边界,而不是强行让一个技术栈包办所有事情。

选择语言时先看等待和约束

可以先问两个问题:

  1. 系统的大部分时间是在等待外部服务,还是在执行本地计算?
  2. 当前最紧的约束是接入迭代速度,还是性能、资源和隔离要求?

如果答案是“大量等待外部服务”和“需要快速接入”,TypeScript 的优先级会更高。如果答案是“本地计算密集”和“底层约束很硬”,Rust 更值得优先考虑。

很多系统最后会采用混合架构:TypeScript 负责产品与编排,Rust 负责底层能力。语言选择最终服务于系统边界,而不是服务于某种技术偏好。

Python 和 TypeScript,解决的不是同一个问题

说到 AI,Python 往往是绕不开的语言。它在模型实验、数据处理和部分成熟的 AI 工具链中积累了大量能力。但这篇文章讨论的重点不是 TypeScript 和 Python 谁更“像 AI”,而是 Agent 系统的不同层应该由什么来承担。

如果工作重点是训练和调用模型、处理数据,Python 仍然可以放在它擅长的位置。TypeScript + Node.js 更值得关注的地方,则是 Agent 的连接层:它要同时接收用户请求,调用模型、MCP、数据库和业务 API,管理异步任务,并通过流式事件把进度返回给产品界面。

所以,语言选择最好从系统边界开始,而不是从语言标签开始。先判断自己写的是模型能力、数据管道,还是连接用户与工具的 Agent 工作流,答案自然会清楚很多。

最后回到最初的问题

JavaScript 和 TypeScript 曾经主要出现在浏览器里,但“前端语言”描述的是历史使用场景,不是它的能力边界。

Node.js 让 JavaScript 进入服务端,并用事件循环和非阻塞 I/O 处理大量网络、文件、数据库和消息调用。TypeScript 再在这套运行环境之上,补充类型、接口、状态和协作能力。

对 Agent 来说,这个组合正好覆盖了它最常见的工作:连接模型、调度工具、等待结果、合并状态、推送过程、持续迭代。

所以,大家使用 TypeScript,真正看中的通常不是它比 JavaScript 多了多少语法,而是它把一套原本偏动态、偏分散的异步调用链,变成了更容易理解和维护的工程系统。

如果准备开始一个 Agent 项目,可以先做三件事:

  1. 列出系统中所有外部 I/O,区分哪些调用可以并发、哪些必须串行;
  2. 给工具输入、工具输出、任务状态和流式事件建立明确类型,并在外部边界增加运行时校验;
  3. 把 CPU 密集、资源隔离和系统级能力单独评估,必要时交给 Rust 或独立服务。

这三步做完,再决定是否使用 TypeScript,通常比先争论语言排名更有价值。

我是 WeiWill,深耕软件工程一线,专注 AI 应用落地与 Agent 开发。