Chinesezjc
1103e36c22
The reap-poll deadline arm sent SIGKILL then finalized immediately, declaring quiescence on mere signal delivery while the group was still dying. It now keeps polling for the group to actually empty (bounded by one more reap margin) after its self-sent SIGKILL, so `finished` resolves only on a confirmed-empty group. ProtocolChannel.read_frame read the boot/run handshake frames through FileIO.readline() on the unbuffered fd — one os.read(1) per byte, so a multi-megabyte program burned CPU (RLIMIT_CPU already in force for the run frame) in millions of syscalls before ast.parse. It now reads in chunks into the same _pending buffer the async reader uses; the wrapping os.fdopen is gone. read_frame is this PR's own code (e7f22ed3), not the protocol layer. The chunked read is a syscall-count improvement with no cross-platform-deterministic failure to assert, noted as such in the Agent Note.
description, kind
| description | kind |
|---|---|
| Package map for the code-execution capability family: what program execution does for you, and which package owns each part. | package-group |
code-runtime/ — code-execution capability family
English | 中文
Summary
The code-runtime/ group provides program execution: a model writes one program that calls host-provided functions as ordinary async calls, and a runtime executes it in isolation and returns only what the program printed and returned. One package defines the shared capability (ctx.codeRuntime), a second executes TypeScript programs in a fresh Node worker thread, and a third owns the wire protocol between a Node host and a CPython subprocess for the Python backend. Every run is independent — no state carries from one program to the next — and failures come back as part of the result, so the caller can see why a program failed and feed that back to the model.
Table of Contents
Packages
These three packages together provide program execution; each README describes what its part does.
| Package | Role | ctx key |
|---|---|---|
code-runtime/ |
Defines what a code runtime does: run one program against host-provided bindings and report what it printed and returned | ctx.codeRuntime |
code-runtime-worker-thread/ |
Executes TypeScript programs, each in a fresh Node worker thread | registers ctx.codeRuntime |
code-runtime-python/ |
Owns the fd-3 wire protocol between a Node host and a CPython subprocess, the Python backend's protocol layer | — |
Related documentation
Start with the subsystem reference for the service contract, then the PTC mode design that consumes this capability and the capability-seam model it follows.
- Code runtime subsystem reference — request/result vocabulary, bindings, and the
ctx.codeRuntimecordis surface. - PTC mode Agent Note — how the tool registry presents
run_codeto the model. - Capability seams — the Service Definition / Service Provider / Consumer split this family follows.
Dev Note
Working context for maintainers — click to expand
None.