mirror of
https://github.com/pchuan98/codex.git
synced 2026-07-01 00:31:56 +08:00
jifandGitHub
d2f6d23c6c
## Why
Extension contributors are registered behind `dyn Trait` objects, so
native `async fn`/RPITIT methods would make these traits
non-object-safe. Spell out the boxed, `Send` future contract directly so
`extension-api` no longer needs `async-trait` while retaining the
existing runtime model.
## What changed
- add a shared `ExtensionFuture` alias and use it for asynchronous
contributor methods
- migrate production and test implementations to return `Box::pin(async
move { ... })`
- remove `async-trait` dependencies where they are no longer used,
keeping it dev-only where unrelated test executors still require it
## Behavior
No behavior change is intended. Contributor futures remain boxed,
`Send`, dynamically dispatched, and lazily executed; cancellation and
callback ordering stay unchanged.
## Testing
- `just test -p codex-extension-api` (11 passed)
- affected extension crates (64 passed)
- targeted `codex-core` contributor tests (14 passed)
- `just fmt`
- `just bazel-lock-update`
- `just bazel-lock-check`
A broad local `codex-core` run compiled successfully but encountered
unrelated sandbox and missing test-binary fixture failures; CI will run
the full checks.
78 lines
2.3 KiB
Rust
78 lines
2.3 KiB
Rust
use std::sync::Arc;
|
|
|
|
use codex_core::config::Config;
|
|
use codex_extension_api::AgentSpawnFuture;
|
|
use codex_extension_api::AgentSpawner;
|
|
use codex_extension_api::ExtensionFuture;
|
|
use codex_extension_api::ExtensionRegistryBuilder;
|
|
use codex_extension_api::ThreadLifecycleContributor;
|
|
use codex_extension_api::ThreadStartInput;
|
|
use codex_protocol::ThreadId;
|
|
|
|
/// Guardian extension dependencies supplied by the host at construction time.
|
|
#[derive(Clone, Debug)]
|
|
pub struct GuardianExtension<S> {
|
|
agent_spawner: S,
|
|
}
|
|
|
|
impl<S> GuardianExtension<S> {
|
|
/// Creates a guardian extension with its host-provided agent spawn helper.
|
|
pub fn new(agent_spawner: S) -> Self {
|
|
Self { agent_spawner }
|
|
}
|
|
|
|
/// Delegates one guardian-owned subagent spawn request to the host helper.
|
|
pub fn spawn_subagent<'a, R>(
|
|
&'a self,
|
|
forked_from_thread_id: ThreadId,
|
|
request: R,
|
|
) -> AgentSpawnFuture<'a, <S as AgentSpawner<R>>::Spawned, <S as AgentSpawner<R>>::Error>
|
|
where
|
|
S: AgentSpawner<R>,
|
|
{
|
|
self.agent_spawner
|
|
.spawn_subagent(forked_from_thread_id, request)
|
|
}
|
|
}
|
|
|
|
/// Thread-local guardian state captured when the host starts a thread.
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct GuardianThreadContext {
|
|
forked_from_thread_id: ThreadId,
|
|
}
|
|
|
|
impl GuardianThreadContext {
|
|
/// Returns the thread that future guardian subagents should fork from by default.
|
|
pub fn forked_from_thread_id(&self) -> ThreadId {
|
|
self.forked_from_thread_id
|
|
}
|
|
}
|
|
|
|
impl<S> ThreadLifecycleContributor<Config> for GuardianExtension<S>
|
|
where
|
|
S: Send + Sync,
|
|
{
|
|
fn on_thread_start<'a>(
|
|
&'a self,
|
|
input: ThreadStartInput<'a, Config>,
|
|
) -> ExtensionFuture<'a, ()> {
|
|
Box::pin(async move {
|
|
let Ok(forked_from_thread_id) = ThreadId::from_string(input.thread_store.level_id())
|
|
else {
|
|
return;
|
|
};
|
|
input.thread_store.insert(GuardianThreadContext {
|
|
forked_from_thread_id,
|
|
});
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Installs the guardian contributors into the extension registry.
|
|
pub fn install<S>(registry: &mut ExtensionRegistryBuilder<Config>, agent_spawner: S)
|
|
where
|
|
S: Send + Sync + 'static,
|
|
{
|
|
registry.thread_lifecycle_contributor(Arc::new(GuardianExtension::new(agent_spawner)));
|
|
}
|