a180ed44e8
With this change, you can specify a program that will be executed to get
notified about events generated by Codex. The notification info will be
packaged as a JSON object. The supported notification types are defined
by the `UserNotification` enum introduced in this PR. Initially, it
contains only one variant, `AgentTurnComplete`:
```rust
pub(crate) enum UserNotification {
#[serde(rename_all = "kebab-case")]
AgentTurnComplete {
turn_id: String,
/// Messages that the user sent to the agent to initiate the turn.
input_messages: Vec<String>,
/// The last message sent by the assistant in the turn.
last_assistant_message: Option<String>,
},
}
```
This is intended to support the common case when a "turn" ends, which
often means it is now your chance to give Codex further instructions.
For example, I have the following in my `~/.codex/config.toml`:
```toml
notify = ["python3", "/Users/mbolin/.codex/notify.py"]
```
I created my own custom notifier script that calls out to
[terminal-notifier](https://github.com/julienXX/terminal-notifier) to
show a desktop push notification on macOS. Contents of `notify.py`:
```python
#!/usr/bin/env python3
import json
import subprocess
import sys
def main() -> int:
if len(sys.argv) != 2:
print("Usage: notify.py <NOTIFICATION_JSON>")
return 1
try:
notification = json.loads(sys.argv[1])
except json.JSONDecodeError:
return 1
match notification_type := notification.get("type"):
case "agent-turn-complete":
assistant_message = notification.get("last-assistant-message")
if assistant_message:
title = f"Codex: {assistant_message}"
else:
title = "Codex: Turn Complete!"
input_messages = notification.get("input_messages", [])
message = " ".join(input_messages)
title += message
case _:
print(f"not sending a push notification for: {notification_type}")
return 0
subprocess.check_output(
[
"terminal-notifier",
"-title",
title,
"-message",
message,
"-group",
"codex",
"-ignoreDnD",
"-activate",
"com.googlecode.iterm2",
]
)
return 0
if __name__ == "__main__":
sys.exit(main())
```
For reference, here are related PRs that tried to add this functionality
to the TypeScript version of the Codex CLI:
* https://github.com/openai/codex/pull/160
* https://github.com/openai/codex/pull/498
79 lines
2.3 KiB
Rust
79 lines
2.3 KiB
Rust
use std::sync::atomic::AtomicU64;
|
|
use std::sync::Arc;
|
|
|
|
use crate::config::Config;
|
|
use crate::protocol::Event;
|
|
use crate::protocol::EventMsg;
|
|
use crate::protocol::Op;
|
|
use crate::protocol::Submission;
|
|
use crate::util::notify_on_sigint;
|
|
use crate::Codex;
|
|
use tokio::sync::Notify;
|
|
|
|
/// Spawn a new [`Codex`] and initialise the session.
|
|
///
|
|
/// Returns the wrapped [`Codex`] **and** the `SessionInitialized` event that
|
|
/// is received as a response to the initial `ConfigureSession` submission so
|
|
/// that callers can surface the information to the UI.
|
|
pub async fn init_codex(config: Config) -> anyhow::Result<(CodexWrapper, Event, Arc<Notify>)> {
|
|
let ctrl_c = notify_on_sigint();
|
|
let codex = CodexWrapper::new(Codex::spawn(ctrl_c.clone())?);
|
|
let init_id = codex
|
|
.submit(Op::ConfigureSession {
|
|
model: config.model.clone(),
|
|
instructions: config.instructions.clone(),
|
|
approval_policy: config.approval_policy,
|
|
sandbox_policy: config.sandbox_policy,
|
|
disable_response_storage: config.disable_response_storage,
|
|
notify: config.notify.clone(),
|
|
})
|
|
.await?;
|
|
|
|
// The first event must be `SessionInitialized`. Validate and forward it to
|
|
// the caller so that they can display it in the conversation history.
|
|
let event = codex.next_event().await?;
|
|
if event.id != init_id
|
|
|| !matches!(
|
|
&event,
|
|
Event {
|
|
id: _id,
|
|
msg: EventMsg::SessionConfigured { .. },
|
|
}
|
|
)
|
|
{
|
|
return Err(anyhow::anyhow!(
|
|
"expected SessionInitialized but got {event:?}"
|
|
));
|
|
}
|
|
|
|
Ok((codex, event, ctrl_c))
|
|
}
|
|
|
|
pub struct CodexWrapper {
|
|
next_id: AtomicU64,
|
|
codex: Codex,
|
|
}
|
|
|
|
impl CodexWrapper {
|
|
fn new(codex: Codex) -> Self {
|
|
Self {
|
|
next_id: AtomicU64::new(0),
|
|
codex,
|
|
}
|
|
}
|
|
|
|
/// Returns the id of the Submission.
|
|
pub async fn submit(&self, op: Op) -> crate::error::Result<String> {
|
|
let id = self
|
|
.next_id
|
|
.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
|
|
.to_string();
|
|
self.codex.submit(Submission { id: id.clone(), op }).await?;
|
|
Ok(id)
|
|
}
|
|
|
|
pub async fn next_event(&self) -> crate::error::Result<Event> {
|
|
self.codex.next_event().await
|
|
}
|
|
}
|