解释器 | LangChain 中文文档

解释器为智能体提供智能体循环内部的可编程的、内存中（in-memory）工作区。智能体编写代码来完成任务，运行时执行代码并只返回相关结果。中间结果不会成为模型上下文的一部分。

如果说沙箱是作用于环境（例如运行命令、安装依赖和编辑文件）的代码优先方式，那么解释器就是组合工具、保留状态并决定哪些信息应返回给模型的代码优先方式。

WARNING

解释器处于beta阶段。API 和生命周期行为可能在版本之间发生变化。

INFO

解释器需要 langchain-quickjs>=0.2.0 和 Python >=3.11。

INFO

解释器需要 @langchain/quickjs。

为什么要使用解释器？

大多数智能体工作都在模型推理和工具调用之间交替进行。模型可以在一轮中发出多次工具调用，但该批次在发出时就被固定下来了。没有另一个模型轮次，任何事情都无法循环、根据结果进行分支、重试失败，或将一次调用的输出输入到下一次调用，而且每个结果都会返回到模型的上下文中。模型还要决定发出多少次调用，因此让它跨数百个项目分派工作是不可靠的，而且它往往只覆盖样本而不是每个项目。

解释器将这种编排转移到代码中，因此模型只需要推理做什么，而不需要推理每个中间步骤。

程序化工具调用（PTC） — 从解释器代码中调用选定的工具，包括循环、重试、分支和并行批次。
动态子智能体 — 从代码分派子智能体，用于大规模输入上的扇出、验证和递归工作流。
有状态的工作 — 在运行时状态中保留中间值，而不会使模型上下文过载。
确定性转换 — 无需再经过一个模型轮次即可对结构化数据进行排序、分组、解析、验证、评分和聚合。

选择模式

在智能体循环内部使用解释器来处理代码：组合工具、保留状态并控制返回给模型的内容。

对环境使用沙箱来处理代码：shell 命令、软件包安装、测试、文件系统编辑和操作系统级执行。

需求	使用
一两个简单的外部调用	常规工具调用
纯内存中的 JavaScript：循环、分支、重试或数据转换（无外部工具）	解释器
从代码编排的多次外部工具调用（需要PTC）	带程序化工具调用（PTC）的解释器
许多独立的工作单元、多种视角，或对大型输入进行递归分析	带动态子智能体的解释器
shell 命令、软件包安装、测试或完整的操作系统文件系统访问	沙箱

快速入门

安装 QuickJS 中间件包，然后通过 create_deep_agent 上的 middleware 参数传递解释器中间件。

安装 QuickJS 中间件包，然后通过 createDeepAgent 上的 middleware 参数传递解释器中间件。

Python · pipPython · uv

bash

pip install -U "deepagents[quickjs]"

bash

uv add "deepagents[quickjs]"

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    middleware=[CodeInterpreterMiddleware()],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openai:gpt-5.5",
    middleware=[CodeInterpreterMiddleware()],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    middleware=[CodeInterpreterMiddleware()],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    middleware=[CodeInterpreterMiddleware()],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    middleware=[CodeInterpreterMiddleware()],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    middleware=[CodeInterpreterMiddleware()],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    middleware=[CodeInterpreterMiddleware()],
)

bash

npm install deepagents @langchain/quickjs

bash

pnpm add deepagents @langchain/quickjs

bash

yarn add deepagents @langchain/quickjs

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  middleware: [createCodeInterpreterMiddleware()],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  middleware: [createCodeInterpreterMiddleware()],
});

解释器的工作原理

中间件会向智能体添加一个 eval 工具。在有用时，智能体编写 JavaScript 并调用 eval；你不需要直接调用解释器。该工具在 QuickJS 上下文中运行代码，其变量可以根据持久化 mode 在 eval 调用之间持续存在。它会捕获 console.log、console.warn 和 console.error，并返回最后一个表达式的结果。

智能体可以编写如下代码：

const rows = [
  { team: "alpha", score: 8 },
  { team: "beta", score: 13 },
  { team: "alpha", score: 21 },
];

const totals = rows.reduce((acc, row) => {
  acc[row.team] = (acc[row.team] ?? 0) + row.score;
  console.log(`${row.team} score: ${acc[row.team]}`);
  return acc;
}, {});

totals;

默认情况下（mode="thread"），解释器状态会在同一线程上的轮次之间持久化。有关 mode 选项和快照生命周期，请参阅持久化。

代码在 QuickJS（一个轻量级 JavaScript 运行时）上运行。默认情况下，解释器代码无法访问主机文件系统、网络、shell、软件包管理器或时钟。它只能进行计算、保存状态、写入 console.log、console.warn 或 console.error，仅此而已。

两个显式桥接扩展了这种能力：

工具，通过程序化工具调用（PTC）。在 tools 命名空间下提供一组作为异步函数的允许列表工具。这些可以是智能体自己的工具，也可以是你定义并传入的独立工具。
子智能体，通过动态子智能体。当智能体配置了子智能体时，解释器会暴露一个 task() 全局函数，用于从代码分派它们。

程序化工具调用默认是关闭的，直到你启用它。只要智能体配置了子智能体，通过 task() 分派子智能体就默认开启，你也可以关闭它。除此之外，没有任何内容跨越 QuickJS 边界。

程序化工具调用（PTC）

程序化工具调用（PTC）在解释器内部的全局 tools 命名空间下暴露选定的智能体工具。智能体不再要求模型发出一次工具调用、等待结果，然后再决定下一次调用，而是可以编写在循环、分支、重试或并行批次中调用工具的代码。

当中间结果只是下一步的输入时，这会很有帮助：解释器会在任何内容返回给模型之前过滤或聚合它们，从而让多步骤工作流保持 token 高效。它与模型无关，由中间件实现，而不是特定于提供商的工具调用 API。

中间件将每个列入允许列表的工具作为 tools 下的异步函数暴露出来。智能体使用 await 调用它，在代码中处理结果，模型只看到最终的解释器输出，而不是每个中间值。工具名称会转换为 camelCase，而输入对象仍然遵循工具的模式，因此名为 web_search 的工具会变成 tools.webSearch(...)：

const result: string = await tools.webSearch({
  query: "deepagents interpreters",
});

启用 PTC

使用显式允许列表启用 PTC：

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openai:gpt-5.5",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    middleware=[CodeInterpreterMiddleware(ptc=["web_search"])],
)

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  middleware: [createCodeInterpreterMiddleware({ ptc: ["web_search"] })],
});

PTC 启用后，智能体可以从解释器代码中调用允许列表中的工具。此示例并行搜索多个主题，并在返回给模型之前合并结果：

const topics = ["retrieval", "memory", "evaluation"];

const results = await Promise.all(
  topics.map((topic) =>
    tools.webSearch({ query: `${topic} best practices 2025` }),
  ),
);

results.join("\n\n");

WARNING

PTC 调用当前通过解释器桥接执行，不会经过常规的工具调用路径。因此，interrupt_on 审批工作流不会对每次 PTC 调用的工具调用强制执行。

WARNING

PTC 调用当前通过解释器桥接执行，不会经过常规的工具调用路径。因此，interruptOn 审批工作流不会对每次 PTC 调用的工具调用强制执行。

动态子智能体

下面的概述涵盖何时使用动态子智能体以及最小化的 task() 模式。有关配置、编排示例、工作流触发器和安全注意事项，请参阅动态子智能体。

动态子智能体让解释器使用内置的 task() 全局函数从代码中分派已配置的子智能体。跨越许多独立单元的任务（例如审查目录中的每个文件或分类一批工单）会变成一个扇出工作并综合结果的循环。

在以下场景使用动态子智能体：

扇出与综合：并行地在许多项目上运行同类型的工作，然后合并结果。
验证：将发现发送给独立的验证子智能体，只保留已确认的结果。
递归工作流：在解释器变量中保留工作集，选择切片，调用子智能体，并优化结果。

const paths = ["src/auth.ts", "src/routes/api.ts"];

const reviews = await Promise.all(
  paths.map((path) =>
    task({
      description: `Review ${path} for authentication issues`,
      subagentType: "reviewer",
    }),
  ),
);

reviews.join("\n\n");

持久化

使用 CodeInterpreterMiddleware 上的 mode 参数控制跨轮次的状态：

"thread"（默认）：状态在 eval 调用之间和智能体轮次之间持久化。中间件在每次智能体轮次后对解释器状态进行快照，并在下一轮之前恢复。
"turn"：状态在一个智能体轮次内的多次 eval 调用之间持久化，然后在下一轮重置。
"call"：每次 eval 调用都在全新的 REPL 中运行，不从前面的调用继承任何内容。

使用 mode="thread" 时，快照是解释器内存中 JavaScript 状态的序列化副本，包括智能体完成运行代码时存在的全局变量、变量、函数和导入的模块。在对话轮次之间，生命周期如下：

一轮开始，中间件为线程恢复最新的解释器快照。
智能体调用 eval 一次或多次。这些调用共享一个活动的上下文；中间件不会在它们之间进行快照。
一轮结束，中间件将更新的快照写入图状态。
下一轮从该快照恢复，而不是从空的运行时开始。

INFO

快照只保留可序列化的数据。函数、类和其他不可序列化的运行时对象在恢复后会变成无法访问的产物。访问它们会抛出类似 Value for 'fn' was not restored because it is not serializable (type: function). 的错误。

快照保留解释器内存，而不是外部世界的效果。如果解释器代码通过 PTC 调用工具，恢复先前的解释器快照并不会撤销该工具调用的副作用。它只恢复记录或处理该结果的解释器变量。

跨轮次持久化不需要检查点器：

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openai:gpt-5.5",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    middleware=[
        CodeInterpreterMiddleware(
            mode="thread",  # Default
        )
    ],
)

由于解释器快照存储在图形状态中，检查点器也会将其捕获在检查点历史中。当你需要持久化线程或时间旅行时，添加一个：

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="openai:gpt-5.5",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

python

from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware
from langgraph.checkpoint.memory import MemorySaver

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    checkpointer=MemorySaver(),
    middleware=[CodeInterpreterMiddleware(mode="thread")],
)

设置 mode="turn" 以仅在轮次内持久化解释器状态，或设置 mode="call" 以在每次 eval 时使用全新的 REPL。

安全性

解释器使用 QuickJS 在严格默认隔离下运行不受信任的 JavaScript。请将其视为作用域受限的解释器运行时，而不是一个完整的生产沙箱后端。

你通过 PTC 暴露的每个工具都是解释器代码可以使用的外部能力。将 PTC 允许列表视为权限边界：只暴露智能体需要的工具，并避免桥接可以访问敏感系统、花费资金、变更数据或调用不受限制网络的宽泛工具，除非这种行为的出现是有意为之。

能力	默认可用	如何暴露
JavaScript 执行	是	添加解释器中间件
顶层 `await`	是	在解释器代码中使用 Promise
`console.log`、`warn`、`error` 捕获	是	使用 `capture_console=False` 禁用
智能体工具	否	添加 PTC 允许列表
文件系统访问	否	通过 PTC 允许列表添加内置文件系统工具
网络访问	否	通过 PTC 暴露特定的网络工具
时钟或日期时间访问	否	如有需要，暴露显式的时间工具
shell 命令、软件包安装、测试、操作系统级执行	否	使用沙箱后端
能力	默认可用	如何暴露
---	---	---
JavaScript 执行	是	添加解释器中间件
顶层 `await`	是	在解释器代码中使用 Promise
`console.log`、`warn`、`error` 捕获	是	使用 `captureConsole: false` 禁用
智能体工具	否	添加 PTC 允许列表
文件系统访问	否	通过 PTC 允许列表添加内置文件系统工具
网络访问	否	通过 PTC 暴露特定的网络工具
时钟或日期时间访问	否	如有需要，暴露显式的时间工具
shell 命令、软件包安装、测试、操作系统级执行	否	使用沙箱后端

INFO

代码执行的工作原理

解释器代码在嵌入式 QuickJS 上下文中运行，而不是在单独的 VM 或进程中。在 Python 中，这个运行时由 quickjs-rs 提供，其安全指南记录了同进程执行边界。

请将解释器视为能力作用域受限的执行层，而不是主机内存隔离边界。对于不受信任或半受信任的代码，请在隔离的工作进程或容器中运行智能体，并保持 PTC 允许列表窄小。

INFO

代码执行的工作原理

解释器代码通过 QuickJS-Emscripten 在 WASM 沙箱化的 QuickJS 运行时中运行，而不是在主机 Node.js 进程中。请将解释器视为能力作用域受限的执行层：只桥接智能体需要的工具和子智能体，并保持 PTC 允许列表窄小。

配置

CodeInterpreterMiddleware 接受以下选项：

Kwarg	默认值	用途
`memory_limit`	`64 * 1024 * 1024` (64 MB)	限制每个线程的 QuickJS 堆内存。
`timeout`	`5.0`	每次 `eval` 调用的超时限制（秒）。
`tool_name`	`"eval"`	暴露给模型的解释器工具的名称。
`capture_console`	`True`	在工具响应中捕获 `console.log`、`console.warn` 和 `console.error`。设置为 `False` 以丢弃控制台输出。
`max_result_chars`	`4000`	将返回给模型的结果、错误和 stdout 文本截断为最大字符数。
`ptc`	`None`	暴露为解释器内部 `tools.*` 的工具名称或 `BaseTool` 实例的允许列表。省略则禁用。请参阅启用 PTC。
`max_ptc_calls`	`256`	每次 `eval` 允许的最大 `tools.*` 调用次数。仅在可信环境中设置为 `None`。请参阅程序化工具调用（PTC）和安全性。
`subagents`	`True`	当智能体配置了子智能体时，暴露内置的 `task()` 全局函数。设置为 `False` 以要求通过常规的 `task` 工具分派。请参阅动态子智能体。
`mode`	`"thread"`	控制解释器持久化：`"thread"`（跨轮次）、`"turn"`（一轮内）或 `"call"`（每次 `eval` 使用全新的 REPL）。请参阅持久化。
`max_snapshot_bytes`	`None`	丢弃大于此字节限制的快照。默认等于 `memory_limit`。请参阅持久化。

createCodeInterpreterMiddleware 接受以下选项：

选项	默认值	用途
`memoryLimitBytes`	`64 * 1024 * 1024` (64 MB)	限制每个会话的 QuickJS 堆内存。
`maxStackSizeBytes`	`320 * 1024`	限制每个会话的 QuickJS 堆栈大小。
`executionTimeoutMs`	`5000`	每次 `eval` 调用的超时限制（毫秒）。负值会禁用超时。
`toolName`	`"eval"`	暴露给模型的解释器工具的名称。
`captureConsole`	`true`	在工具响应中捕获 `console.log`、`console.warn` 和 `console.error`。设置为 `false` 以丢弃控制台输出。
`maxResultChars`	`4000`	将返回给模型的结果、错误和控制台输出截断为最大字符数。
`systemPrompt`	`null`	解释器工具的自定义系统提示词。为 `null` 时默认为内置提示词。
`ptc`	省略	暴露为解释器内部 `tools.*` 的工具名称或 `StructuredToolInterface` 实例的允许列表。省略则禁用。请参阅启用 PTC。
`maxPtcCalls`	`256`	每次 `eval` 允许的最大 `tools.*` 调用次数。仅在可信环境中设置为 `null`。请参阅程序化工具调用（PTC）和安全性。
`subagents`	`true`	当智能体配置了子智能体时，暴露内置的 `task()` 全局函数。设置为 `false` 以要求通过常规的 `task` 工具分派。请参阅动态子智能体。

Going to production

Interpreters

Patterns

Configuration

为什么要使用解释器？

选择模式

快速入门

解释器的工作原理

程序化工具调用（PTC）

启用 PTC

动态子智能体

持久化

安全性

配置

为什么要使用解释器？ ​

选择模式 ​

快速入门 ​

解释器的工作原理 ​

程序化工具调用（PTC） ​

启用 PTC ​

动态子智能体 ​

持久化 ​

安全性 ​

配置 ​

为什么要使用解释器？

选择模式

快速入门

解释器的工作原理

程序化工具调用（PTC）

启用 PTC

动态子智能体

持久化

安全性

配置