valknar/llmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Phase 2: Rust Workspace Transformation (Part 1)

Browse Source 
- Renamed directory: codex-backend-openapi-models -> llmx-backend-openapi-models
- Updated all Cargo.toml files:
  - Package names: codex-* -> llmx-*
  - Library names: codex_* -> llmx_*
  - Workspace dependencies updated
- Renamed Rust source files:
  - codex*.rs -> llmx*.rs (all modules)
  - codex_conversation -> llmx_conversation
  - codex_delegate -> llmx_delegate
  - codex_message_processor -> llmx_message_processor
  - codex_tool_* -> llmx_tool_*
- Updated all Rust imports:
  - use codex_* -> use llmx_*
  - mod codex* -> mod llmx*
- Updated environment variables in code:
  - CODEX_HOME -> LLMX_HOME
  - .codex -> .llmx paths
- Updated protocol crate lib name for proper linking

Note: Some compilation errors remain (type inference issues) but all
renaming is complete. Will fix compilation in next phase.

🤖 Generated with Claude Code
This commit is contained in:
Sebastian Krüger
2025-11-11 14:29:57 +01:00
parent f237fe560d
commit cb8d941adf
346 changed files with 3256 additions and 3199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
llmx-rs/core/Cargo.toml
View File

@@ -1,11 +1,11 @@
[package]
edition = "2024"
name = "codex-core"
name = "llmx-core"
version = { workspace = true }
[lib]
doctest = false
name = "codex_core"
name = "llmx_core"
path = "src/lib.rs"
[lints]
@@ -19,20 +19,20 @@ async-trait = { workspace = true }
base64 = { workspace = true }
bytes = { workspace = true }
chrono = { workspace = true, features = ["serde"] }
codex-app-server-protocol = { workspace = true }
codex-apply-patch = { workspace = true }
codex-async-utils = { workspace = true }
codex-file-search = { workspace = true }
codex-git = { workspace = true }
codex-keyring-store = { workspace = true }
codex-otel = { workspace = true, features = ["otel"] }
codex-protocol = { workspace = true }
codex-rmcp-client = { workspace = true }
codex-utils-pty = { workspace = true }
codex-utils-readiness = { workspace = true }
codex-utils-string = { workspace = true }
codex-utils-tokenizer = { workspace = true }
codex-windows-sandbox = { package = "codex-windows-sandbox", path = "../windows-sandbox-rs" }
llmx-app-server-protocol = { workspace = true }
llmx-apply-patch = { workspace = true }
llmx-async-utils = { workspace = true }
llmx-file-search = { workspace = true }
llmx-git = { workspace = true }
llmx-keyring-store = { workspace = true }
llmx-otel = { workspace = true, features = ["otel"] }
llmx-protocol = { workspace = true }
llmx-rmcp-client = { workspace = true }
llmx-utils-pty = { workspace = true }
llmx-utils-readiness = { workspace = true }
llmx-utils-string = { workspace = true }
llmx-utils-tokenizer = { workspace = true }
llmx-windows-sandbox = { package = "llmx-windows-sandbox", path = "../windows-sandbox-rs" }
dirs = { workspace = true }
dunce = { workspace = true }
env-flags = { workspace = true }
@@ -104,7 +104,7 @@ openssl-sys = { workspace = true, features = ["vendored"] }
[dev-dependencies]
assert_cmd = { workspace = true }
assert_matches = { workspace = true }
codex-arg0 = { workspace = true }
llmx-arg0 = { workspace = true }
core_test_support = { workspace = true }
ctor = { workspace = true }
escargot = { workspace = true }

4
llmx-rs/core/src/apply_patch.rs
View File

@@ -5,8 +5,8 @@ use crate::protocol::FileChange;
use crate::protocol::ReviewDecision;
use crate::safety::SafetyCheck;
use crate::safety::assess_patch_safety;
use codex_apply_patch::ApplyPatchAction;
use codex_apply_patch::ApplyPatchFileChange;
use llmx_apply_patch::ApplyPatchAction;
use llmx_apply_patch::ApplyPatchFileChange;
use std::collections::HashMap;
use std::path::PathBuf;

10
llmx-rs/core/src/auth.rs
View File

@@ -15,8 +15,8 @@ use std::sync::Arc;
use std::sync::Mutex;
use std::time::Duration;
use codex_app_server_protocol::AuthMode;
use codex_protocol::config_types::ForcedLoginMethod;
use llmx_app_server_protocol::AuthMode;
use llmx_protocol::config_types::ForcedLoginMethod;
pub use crate::auth::storage::AuthCredentialsStoreMode;
pub use crate::auth::storage::AuthDotJson;
@@ -31,7 +31,7 @@ use crate::token_data::PlanType as InternalPlanType;
use crate::token_data::TokenData;
use crate::token_data::parse_id_token;
use crate::util::try_parse_error_message;
use codex_protocol::account::PlanType as AccountPlanType;
use llmx_protocol::account::PlanType as AccountPlanType;
use serde_json::Value;
use thiserror::Error;
@@ -640,10 +640,10 @@ mod tests {
use crate::token_data::IdTokenInfo;
use crate::token_data::KnownPlan as InternalKnownPlan;
use crate::token_data::PlanType as InternalPlanType;
use codex_protocol::account::PlanType as AccountPlanType;
use llmx_protocol::account::PlanType as AccountPlanType;
use base64::Engine;
use codex_protocol::config_types::ForcedLoginMethod;
use llmx_protocol::config_types::ForcedLoginMethod;
use pretty_assertions::assert_eq;
use serde::Serialize;
use serde_json::json;

6
llmx-rs/core/src/auth/storage.rs
View File

@@ -17,8 +17,8 @@ use std::sync::Arc;
use tracing::warn;
use crate::token_data::TokenData;
use codex_keyring_store::DefaultKeyringStore;
use codex_keyring_store::KeyringStore;
use llmx_keyring_store::DefaultKeyringStore;
use llmx_keyring_store::KeyringStore;
/// Determine where Codex should store CLI auth credentials.
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -287,7 +287,7 @@ mod tests {
use serde_json::json;
use tempfile::tempdir;
use codex_keyring_store::tests::MockKeyringStore;
use llmx_keyring_store::tests::MockKeyringStore;
use keyring::Error as KeyringError;
#[tokio::test]

28
llmx-rs/core/src/chat_completions.rs
View File

@@ -15,13 +15,13 @@ use crate::model_family::ModelFamily;
use crate::tools::spec::create_tools_json_for_chat_completions_api;
use crate::util::backoff;
use bytes::Bytes;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::models::ContentItem;
use codex_protocol::models::FunctionCallOutputContentItem;
use codex_protocol::models::ReasoningItemContent;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::SubAgentSource;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::FunctionCallOutputContentItem;
use llmx_protocol::models::ReasoningItemContent;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::SessionSource;
use llmx_protocol::protocol::SubAgentSource;
use eventsource_stream::Eventsource;
use futures::Stream;
use futures::StreamExt;
@@ -774,7 +774,7 @@ where
let is_assistant_message = matches!(
&item,
codex_protocol::models::ResponseItem::Message { role, .. } if role == "assistant"
llmx_protocol::models::ResponseItem::Message { role, .. } if role == "assistant"
);
if is_assistant_message {
@@ -784,12 +784,12 @@ where
// seen any deltas; otherwise, deltas already built the
// cumulative text and this would duplicate it.
if this.cumulative.is_empty()
&& let codex_protocol::models::ResponseItem::Message {
&& let llmx_protocol::models::ResponseItem::Message {
content,
..
} = &item
&& let Some(text) = content.iter().find_map(|c| match c {
codex_protocol::models::ContentItem::OutputText {
llmx_protocol::models::ContentItem::OutputText {
text,
} => Some(text),
_ => None,
@@ -832,11 +832,11 @@ where
&& matches!(this.mode, AggregateMode::AggregatedOnly)
{
let aggregated_reasoning =
codex_protocol::models::ResponseItem::Reasoning {
llmx_protocol::models::ResponseItem::Reasoning {
id: String::new(),
summary: Vec::new(),
content: Some(vec![
codex_protocol::models::ReasoningItemContent::ReasoningText {
llmx_protocol::models::ReasoningItemContent::ReasoningText {
text: std::mem::take(&mut this.cumulative_reasoning),
},
]),
@@ -853,10 +853,10 @@ where
// the streamed deltas into a terminal OutputItemDone so callers
// can persist/render the message once per turn.
if !this.cumulative.is_empty() {
let aggregated_message = codex_protocol::models::ResponseItem::Message {
let aggregated_message = llmx_protocol::models::ResponseItem::Message {
id: None,
role: "assistant".to_string(),
content: vec![codex_protocol::models::ContentItem::OutputText {
content: vec![llmx_protocol::models::ContentItem::OutputText {
text: std::mem::take(&mut this.cumulative),
}],
};

14
llmx-rs/core/src/client.rs
View File

@@ -7,13 +7,13 @@ use std::time::Duration;
use bytes::Bytes;
use chrono::DateTime;
use chrono::Utc;
use codex_app_server_protocol::AuthMode;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::ConversationId;
use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::SessionSource;
use llmx_app_server_protocol::AuthMode;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::ConversationId;
use llmx_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
use llmx_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::SessionSource;
use eventsource_stream::Eventsource;
use futures::prelude::*;
use regex_lite::Regex;

10
llmx-rs/core/src/client_common.rs
View File

@@ -3,11 +3,11 @@ use crate::error::Result;
use crate::model_family::ModelFamily;
use crate::protocol::RateLimitSnapshot;
use crate::protocol::TokenUsage;
use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
use codex_protocol::config_types::Verbosity as VerbosityConfig;
use codex_protocol::models::ResponseItem;
use llmx_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
use llmx_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
use llmx_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
use llmx_protocol::config_types::Verbosity as VerbosityConfig;
use llmx_protocol::models::ResponseItem;
use futures::Stream;
use serde::Deserialize;
use serde::Serialize;

4
llmx-rs/core/src/command_safety/is_dangerous_command.rs
View File

@@ -1,5 +1,5 @@
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::SandboxPolicy;
use llmx_protocol::protocol::AskForApproval;
use llmx_protocol::protocol::SandboxPolicy;
use crate::bash::parse_shell_lc_plain_commands;
use crate::is_safe_command::is_known_safe_command;

12
llmx-rs/core/src/compact.rs
View File

@@ -16,12 +16,12 @@ use crate::protocol::TurnContextItem;
use crate::protocol::WarningEvent;
use crate::truncate::truncate_middle;
use crate::util::backoff;
use codex_protocol::items::TurnItem;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::user_input::UserInput;
use llmx_protocol::items::TurnItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseInputItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::RolloutItem;
use llmx_protocol::user_input::UserInput;
use futures::prelude::*;
use tracing::error;

4
llmx-rs/core/src/config/edit.rs
View File

@@ -2,7 +2,7 @@ use crate::config::CONFIG_TOML_FILE;
use crate::config::types::McpServerConfig;
use crate::config::types::Notice;
use anyhow::Context;
use codex_protocol::config_types::ReasoningEffort;
use llmx_protocol::config_types::ReasoningEffort;
use std::collections::BTreeMap;
use std::path::Path;
use std::path::PathBuf;
@@ -536,7 +536,7 @@ impl ConfigEditsBuilder {
mod tests {
use super::*;
use crate::config::types::McpServerTransportConfig;
use codex_protocol::config_types::ReasoningEffort;
use llmx_protocol::config_types::ReasoningEffort;
use pretty_assertions::assert_eq;
use tempfile::tempdir;
use tokio::runtime::Builder;

16
llmx-rs/core/src/config/mod.rs
View File

@@ -32,14 +32,14 @@ use crate::project_doc::DEFAULT_PROJECT_DOC_FILENAME;
use crate::project_doc::LOCAL_PROJECT_DOC_FILENAME;
use crate::protocol::AskForApproval;
use crate::protocol::SandboxPolicy;
use codex_app_server_protocol::Tools;
use codex_app_server_protocol::UserSavedConfig;
use codex_protocol::config_types::ForcedLoginMethod;
use codex_protocol::config_types::ReasoningEffort;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::config_types::SandboxMode;
use codex_protocol::config_types::Verbosity;
use codex_rmcp_client::OAuthCredentialsStoreMode;
use llmx_app_server_protocol::Tools;
use llmx_app_server_protocol::UserSavedConfig;
use llmx_protocol::config_types::ForcedLoginMethod;
use llmx_protocol::config_types::ReasoningEffort;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::config_types::SandboxMode;
use llmx_protocol::config_types::Verbosity;
use llmx_rmcp_client::OAuthCredentialsStoreMode;
use dirs::home_dir;
use dunce::canonicalize;
use serde::Deserialize;

10
llmx-rs/core/src/config/profile.rs
View File

@@ -2,10 +2,10 @@ use serde::Deserialize;
use std::path::PathBuf;
use crate::protocol::AskForApproval;
use codex_protocol::config_types::ReasoningEffort;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::config_types::SandboxMode;
use codex_protocol::config_types::Verbosity;
use llmx_protocol::config_types::ReasoningEffort;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::config_types::SandboxMode;
use llmx_protocol::config_types::Verbosity;
/// Collection of common configuration options that a user can define as a unit
/// in `config.toml`.
@@ -35,7 +35,7 @@ pub struct ConfigProfile {
pub features: Option<crate::features::FeaturesToml>,
}
impl From<ConfigProfile> for codex_app_server_protocol::Profile {
impl From<ConfigProfile> for llmx_app_server_protocol::Profile {
fn from(config_profile: ConfigProfile) -> Self {
Self {
model: config_profile.model,

2
llmx-rs/core/src/config/types.rs
View File

@@ -381,7 +381,7 @@ pub struct SandboxWorkspaceWrite {
pub exclude_slash_tmp: bool,
}
impl From<SandboxWorkspaceWrite> for codex_app_server_protocol::SandboxSettings {
impl From<SandboxWorkspaceWrite> for llmx_app_server_protocol::SandboxSettings {
fn from(sandbox_workspace_write: SandboxWorkspaceWrite) -> Self {
Self {
writable_roots: sandbox_workspace_write.writable_roots,

8
llmx-rs/core/src/context_manager/history.rs
View File

@@ -1,7 +1,7 @@
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::TokenUsage;
use codex_protocol::protocol::TokenUsageInfo;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::TokenUsage;
use llmx_protocol::protocol::TokenUsageInfo;
use std::ops::Deref;
use crate::context_manager::normalize;

18
llmx-rs/core/src/context_manager/history_tests.rs
View File

@@ -1,14 +1,14 @@
use super::*;
use crate::context_manager::truncate;
use codex_git::GhostCommit;
use codex_protocol::models::ContentItem;
use codex_protocol::models::FunctionCallOutputContentItem;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::LocalShellAction;
use codex_protocol::models::LocalShellExecAction;
use codex_protocol::models::LocalShellStatus;
use codex_protocol::models::ReasoningItemContent;
use codex_protocol::models::ReasoningItemReasoningSummary;
use llmx_git::GhostCommit;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::FunctionCallOutputContentItem;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::LocalShellAction;
use llmx_protocol::models::LocalShellExecAction;
use llmx_protocol::models::LocalShellStatus;
use llmx_protocol::models::ReasoningItemContent;
use llmx_protocol::models::ReasoningItemReasoningSummary;
use pretty_assertions::assert_eq;
use regex_lite::Regex;

4
llmx-rs/core/src/context_manager/normalize.rs
View File

@@ -1,7 +1,7 @@
use std::collections::HashSet;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseItem;
use crate::util::error_or_panic;

6
llmx-rs/core/src/context_manager/truncate.rs
View File

@@ -1,6 +1,6 @@
use codex_protocol::models::FunctionCallOutputContentItem;
use codex_utils_string::take_bytes_at_char_boundary;
use codex_utils_string::take_last_bytes_at_char_boundary;
use llmx_protocol::models::FunctionCallOutputContentItem;
use llmx_utils_string::take_bytes_at_char_boundary;
use llmx_utils_string::take_last_bytes_at_char_boundary;
// Model-formatting limits: clients get full streams; only content sent to the model is truncated.
pub(crate) const MODEL_FORMAT_MAX_BYTES: usize = 10 * 1024; // 10 KiB

20
llmx-rs/core/src/conversation_manager.rs
View File

@@ -3,7 +3,7 @@ use crate::CodexAuth;
use crate::codex::Codex;
use crate::codex::CodexSpawnOk;
use crate::codex::INITIAL_SUBMIT_ID;
use crate::codex_conversation::CodexConversation;
use crate::llmx_conversation::CodexConversation;
use crate::config::Config;
use crate::error::CodexErr;
use crate::error::Result as CodexResult;
@@ -11,12 +11,12 @@ use crate::protocol::Event;
use crate::protocol::EventMsg;
use crate::protocol::SessionConfiguredEvent;
use crate::rollout::RolloutRecorder;
use codex_protocol::ConversationId;
use codex_protocol::items::TurnItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::InitialHistory;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::SessionSource;
use llmx_protocol::ConversationId;
use llmx_protocol::items::TurnItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::InitialHistory;
use llmx_protocol::protocol::RolloutItem;
use llmx_protocol::protocol::SessionSource;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
@@ -231,9 +231,9 @@ mod tests {
use super::*;
use crate::codex::make_session_and_context;
use assert_matches::assert_matches;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ReasoningItemReasoningSummary;
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ReasoningItemReasoningSummary;
use llmx_protocol::models::ResponseItem;
use pretty_assertions::assert_eq;
fn user_msg(text: &str) -> ResponseItem {

2
llmx-rs/core/src/custom_prompts.rs
View File

@@ -1,4 +1,4 @@
use codex_protocol::custom_prompts::CustomPrompt;
use llmx_protocol::custom_prompts::CustomPrompt;
use std::collections::HashSet;
use std::path::Path;
use std::path::PathBuf;

10
llmx-rs/core/src/environment_context.rs
View File

@@ -6,11 +6,11 @@ use crate::codex::TurnContext;
use crate::protocol::AskForApproval;
use crate::protocol::SandboxPolicy;
use crate::shell::Shell;
use codex_protocol::config_types::SandboxMode;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG;
use codex_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG;
use llmx_protocol::config_types::SandboxMode;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG;
use llmx_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG;
use std::path::PathBuf;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, DeriveDisplay)]

8
llmx-rs/core/src/error.rs
View File

@@ -7,9 +7,9 @@ use chrono::DateTime;
use chrono::Datelike;
use chrono::Local;
use chrono::Utc;
use codex_async_utils::CancelErr;
use codex_protocol::ConversationId;
use codex_protocol::protocol::RateLimitSnapshot;
use llmx_async_utils::CancelErr;
use llmx_protocol::ConversationId;
use llmx_protocol::protocol::RateLimitSnapshot;
use reqwest::StatusCode;
use serde_json;
use std::io;
@@ -472,7 +472,7 @@ mod tests {
use chrono::Duration as ChronoDuration;
use chrono::TimeZone;
use chrono::Utc;
use codex_protocol::protocol::RateLimitWindow;
use llmx_protocol::protocol::RateLimitWindow;
use pretty_assertions::assert_eq;
fn rate_limit_snapshot() -> RateLimitSnapshot {

40
llmx-rs/core/src/event_mapping.rs
View File

@@ -1,15 +1,15 @@
use codex_protocol::items::AgentMessageContent;
use codex_protocol::items::AgentMessageItem;
use codex_protocol::items::ReasoningItem;
use codex_protocol::items::TurnItem;
use codex_protocol::items::UserMessageItem;
use codex_protocol::items::WebSearchItem;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ReasoningItemContent;
use codex_protocol::models::ReasoningItemReasoningSummary;
use codex_protocol::models::ResponseItem;
use codex_protocol::models::WebSearchAction;
use codex_protocol::user_input::UserInput;
use llmx_protocol::items::AgentMessageContent;
use llmx_protocol::items::AgentMessageItem;
use llmx_protocol::items::ReasoningItem;
use llmx_protocol::items::TurnItem;
use llmx_protocol::items::UserMessageItem;
use llmx_protocol::items::WebSearchItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ReasoningItemContent;
use llmx_protocol::models::ReasoningItemReasoningSummary;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::models::WebSearchAction;
use llmx_protocol::user_input::UserInput;
use tracing::warn;
use uuid::Uuid;
@@ -126,14 +126,14 @@ pub fn parse_turn_item(item: &ResponseItem) -> Option<TurnItem> {
#[cfg(test)]
mod tests {
use super::parse_turn_item;
use codex_protocol::items::AgentMessageContent;
use codex_protocol::items::TurnItem;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ReasoningItemContent;
use codex_protocol::models::ReasoningItemReasoningSummary;
use codex_protocol::models::ResponseItem;
use codex_protocol::models::WebSearchAction;
use codex_protocol::user_input::UserInput;
use llmx_protocol::items::AgentMessageContent;
use llmx_protocol::items::TurnItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ReasoningItemContent;
use llmx_protocol::models::ReasoningItemReasoningSummary;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::models::WebSearchAction;
use llmx_protocol::user_input::UserInput;
use pretty_assertions::assert_eq;
#[test]

2
llmx-rs/core/src/exec.rs
View File

@@ -172,7 +172,7 @@ async fn exec_windows_sandbox(
sandbox_policy: &SandboxPolicy,
) -> Result<RawExecToolCallOutput> {
use crate::config::find_codex_home;
use codex_windows_sandbox::run_windows_sandbox_capture;
use llmx_windows_sandbox::run_windows_sandbox_capture;
let ExecParams {
command,

4
llmx-rs/core/src/git_info.rs
View File

@@ -2,8 +2,8 @@ use std::collections::HashSet;
use std::path::Path;
use std::path::PathBuf;
use codex_app_server_protocol::GitSha;
use codex_protocol::protocol::GitInfo;
use llmx_app_server_protocol::GitSha;
use llmx_protocol::protocol::GitInfo;
use futures::future::join_all;
use serde::Deserialize;
use serde::Serialize;

26
llmx-rs/core/src/lib.rs
View File

@@ -11,10 +11,10 @@ pub mod bash;
mod chat_completions;
mod client;
mod client_common;
pub mod codex;
mod codex_conversation;
pub use codex_conversation::CodexConversation;
mod codex_delegate;
pub mod llmx;
mod llmx_conversation;
pub use llmx_conversation::CodexConversation;
mod llmx_delegate;
mod command_safety;
pub mod config;
pub mod config_loader;
@@ -48,7 +48,7 @@ pub use model_provider_info::create_oss_provider_with_base_url;
mod conversation_manager;
mod event_mapping;
pub mod review_format;
pub use codex_protocol::protocol::InitialHistory;
pub use llmx_protocol::protocol::InitialHistory;
pub use conversation_manager::ConversationManager;
pub use conversation_manager::NewConversation;
// Re-export common auth types for workspace consumers
@@ -89,22 +89,22 @@ pub use command_safety::is_safe_command;
pub use safety::get_platform_sandbox;
pub use safety::set_windows_sandbox_enabled;
// Re-export the protocol types from the standalone `codex-protocol` crate so existing
// `codex_core::protocol::...` references continue to work across the workspace.
pub use codex_protocol::protocol;
// `llmx_core::protocol::...` references continue to work across the workspace.
pub use llmx_protocol::protocol;
// Re-export protocol config enums to ensure call sites can use the same types
// as those in the protocol crate when constructing protocol messages.
pub use codex_protocol::config_types as protocol_config_types;
pub use llmx_protocol::config_types as protocol_config_types;
pub use client::ModelClient;
pub use client_common::Prompt;
pub use client_common::REVIEW_PROMPT;
pub use client_common::ResponseEvent;
pub use client_common::ResponseStream;
pub use codex_protocol::models::ContentItem;
pub use codex_protocol::models::LocalShellAction;
pub use codex_protocol::models::LocalShellExecAction;
pub use codex_protocol::models::LocalShellStatus;
pub use codex_protocol::models::ResponseItem;
pub use llmx_protocol::models::ContentItem;
pub use llmx_protocol::models::LocalShellAction;
pub use llmx_protocol::models::LocalShellExecAction;
pub use llmx_protocol::models::LocalShellStatus;
pub use llmx_protocol::models::ResponseItem;
pub use compact::content_items_to_text;
pub use event_mapping::parse_turn_item;
pub mod compact;

82
llmx-rs/core/src/codex.rs → llmx-rs/core/src/llmx.rs
View File

@@ -19,19 +19,19 @@ use crate::user_notification::UserNotifier;
use crate::util::error_or_panic;
use async_channel::Receiver;
use async_channel::Sender;
use codex_protocol::ConversationId;
use codex_protocol::items::TurnItem;
use codex_protocol::protocol::FileChange;
use codex_protocol::protocol::HasLegacyEvent;
use codex_protocol::protocol::ItemCompletedEvent;
use codex_protocol::protocol::ItemStartedEvent;
use codex_protocol::protocol::RawResponseItemEvent;
use codex_protocol::protocol::ReviewRequest;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::TaskStartedEvent;
use codex_protocol::protocol::TurnAbortReason;
use codex_protocol::protocol::TurnContextItem;
use llmx_protocol::ConversationId;
use llmx_protocol::items::TurnItem;
use llmx_protocol::protocol::FileChange;
use llmx_protocol::protocol::HasLegacyEvent;
use llmx_protocol::protocol::ItemCompletedEvent;
use llmx_protocol::protocol::ItemStartedEvent;
use llmx_protocol::protocol::RawResponseItemEvent;
use llmx_protocol::protocol::ReviewRequest;
use llmx_protocol::protocol::RolloutItem;
use llmx_protocol::protocol::SessionSource;
use llmx_protocol::protocol::TaskStartedEvent;
use llmx_protocol::protocol::TurnAbortReason;
use llmx_protocol::protocol::TurnContextItem;
use futures::future::BoxFuture;
use futures::prelude::*;
use futures::stream::FuturesOrdered;
@@ -119,18 +119,18 @@ use crate::user_instructions::DeveloperInstructions;
use crate::user_instructions::UserInstructions;
use crate::user_notification::UserNotification;
use crate::util::backoff;
use codex_async_utils::OrCancelExt;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
use codex_protocol::models::ContentItem;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::InitialHistory;
use codex_protocol::user_input::UserInput;
use codex_utils_readiness::Readiness;
use codex_utils_readiness::ReadinessFlag;
use llmx_async_utils::OrCancelExt;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
use llmx_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseInputItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::InitialHistory;
use llmx_protocol::user_input::UserInput;
use llmx_utils_readiness::Readiness;
use llmx_utils_readiness::ReadinessFlag;
/// The high-level interface to the Codex system.
/// It operates as a queue pair where you send submissions and receive events.
@@ -1352,16 +1352,16 @@ mod handlers {
use crate::tasks::RegularTask;
use crate::tasks::UndoTask;
use crate::tasks::UserShellCommandTask;
use codex_protocol::custom_prompts::CustomPrompt;
use codex_protocol::protocol::ErrorEvent;
use codex_protocol::protocol::Event;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ListCustomPromptsResponseEvent;
use codex_protocol::protocol::Op;
use codex_protocol::protocol::ReviewDecision;
use codex_protocol::protocol::ReviewRequest;
use codex_protocol::protocol::TurnAbortReason;
use codex_protocol::user_input::UserInput;
use llmx_protocol::custom_prompts::CustomPrompt;
use llmx_protocol::protocol::ErrorEvent;
use llmx_protocol::protocol::Event;
use llmx_protocol::protocol::EventMsg;
use llmx_protocol::protocol::ListCustomPromptsResponseEvent;
use llmx_protocol::protocol::Op;
use llmx_protocol::protocol::ReviewDecision;
use llmx_protocol::protocol::ReviewRequest;
use llmx_protocol::protocol::TurnAbortReason;
use llmx_protocol::user_input::UserInput;
use std::sync::Arc;
use tracing::info;
use tracing::warn;
@@ -1497,7 +1497,7 @@ mod handlers {
crate::protocol::GetHistoryEntryResponseEvent {
offset,
log_id,
entry: entry_opt.map(|e| codex_protocol::message_history::HistoryEntry {
entry: entry_opt.map(|e| llmx_protocol::message_history::HistoryEntry {
conversation_id: e.session_id,
ts: e.ts,
text: e.text,
@@ -2022,7 +2022,7 @@ async fn try_run_turn(
// `response.completed`) bubble up and trigger the caller's retry logic.
let event = match stream.next().or_cancel(&cancellation_token).await {
Ok(event) => event,
Err(codex_async_utils::CancelErr::Cancelled) => {
Err(llmx_async_utils::CancelErr::Cancelled) => {
let processed_items = output.try_collect().await?;
return Err(CodexErr::TurnAborted {
dangling_artifacts: processed_items,
@@ -2325,10 +2325,10 @@ mod tests {
use crate::tools::handlers::ShellHandler;
use crate::tools::registry::ToolHandler;
use crate::turn_diff_tracker::TurnDiffTracker;
use codex_app_server_protocol::AuthMode;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::McpAuthStatus;
use llmx_app_server_protocol::AuthMode;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::McpAuthStatus;
use std::time::Duration;
use tokio::time::sleep;

0
llmx-rs/core/src/codex_conversation.rs → llmx-rs/core/src/llmx_conversation.rs
View File

36
llmx-rs/core/src/codex_delegate.rs → llmx-rs/core/src/llmx_delegate.rs
View File

@@ -3,16 +3,16 @@ use std::sync::atomic::AtomicU64;
use async_channel::Receiver;
use async_channel::Sender;
use codex_async_utils::OrCancelExt;
use codex_protocol::protocol::ApplyPatchApprovalRequestEvent;
use codex_protocol::protocol::Event;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ExecApprovalRequestEvent;
use codex_protocol::protocol::Op;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::SubAgentSource;
use codex_protocol::protocol::Submission;
use codex_protocol::user_input::UserInput;
use llmx_async_utils::OrCancelExt;
use llmx_protocol::protocol::ApplyPatchApprovalRequestEvent;
use llmx_protocol::protocol::Event;
use llmx_protocol::protocol::EventMsg;
use llmx_protocol::protocol::ExecApprovalRequestEvent;
use llmx_protocol::protocol::Op;
use llmx_protocol::protocol::SessionSource;
use llmx_protocol::protocol::SubAgentSource;
use llmx_protocol::protocol::Submission;
use llmx_protocol::user_input::UserInput;
use tokio_util::sync::CancellationToken;
use crate::AuthManager;
@@ -23,14 +23,14 @@ use crate::codex::Session;
use crate::codex::TurnContext;
use crate::config::Config;
use crate::error::CodexErr;
use codex_protocol::protocol::InitialHistory;
use llmx_protocol::protocol::InitialHistory;
/// Start an interactive sub-Codex conversation and return IO channels.
///
/// The returned `events_rx` yields non-approval events emitted by the sub-agent.
/// Approval requests are handled via `parent_session` and are not surfaced.
/// The returned `ops_tx` allows the caller to submit additional `Op`s to the sub-agent.
pub(crate) async fn run_codex_conversation_interactive(
pub(crate) async fn run_llmx_conversation_interactive(
config: Config,
auth_manager: Arc<AuthManager>,
parent_session: Arc<Session>,
@@ -87,7 +87,7 @@ pub(crate) async fn run_codex_conversation_interactive(
/// Convenience wrapper for one-time use with an initial prompt.
///
/// Internally calls the interactive variant, then immediately submits the provided input.
pub(crate) async fn run_codex_conversation_one_shot(
pub(crate) async fn run_llmx_conversation_one_shot(
config: Config,
auth_manager: Arc<AuthManager>,
input: Vec<UserInput>,
@@ -99,7 +99,7 @@ pub(crate) async fn run_codex_conversation_one_shot(
// Use a child token so we can stop the delegate after completion without
// requiring the caller to cancel the parent token.
let child_cancel = cancel_token.child_token();
let io = run_codex_conversation_interactive(
let io = run_llmx_conversation_interactive(
config,
auth_manager,
parent_session,
@@ -281,17 +281,17 @@ async fn await_approval_with_cancel<F>(
parent_session: &Session,
sub_id: &str,
cancel_token: &CancellationToken,
) -> codex_protocol::protocol::ReviewDecision
) -> llmx_protocol::protocol::ReviewDecision
where
F: core::future::Future<Output = codex_protocol::protocol::ReviewDecision>,
F: core::future::Future<Output = llmx_protocol::protocol::ReviewDecision>,
{
tokio::select! {
biased;
_ = cancel_token.cancelled() => {
parent_session
.notify_approval(sub_id, codex_protocol::protocol::ReviewDecision::Abort)
.notify_approval(sub_id, llmx_protocol::protocol::ReviewDecision::Abort)
.await;
codex_protocol::protocol::ReviewDecision::Abort
llmx_protocol::protocol::ReviewDecision::Abort
}
decision = fut => {
decision

6
llmx-rs/core/src/mcp/auth.rs
View File

@@ -1,9 +1,9 @@
use std::collections::HashMap;
use anyhow::Result;
use codex_protocol::protocol::McpAuthStatus;
use codex_rmcp_client::OAuthCredentialsStoreMode;
use codex_rmcp_client::determine_streamable_http_auth_status;
use llmx_protocol::protocol::McpAuthStatus;
use llmx_rmcp_client::OAuthCredentialsStoreMode;
use llmx_rmcp_client::determine_streamable_http_auth_status;
use futures::future::join_all;
use tracing::warn;

6
llmx-rs/core/src/mcp_connection_manager.rs
View File

@@ -1,6 +1,6 @@
//! Connection manager for Model Context Protocol (MCP) servers.
//!
//! The [`McpConnectionManager`] owns one [`codex_rmcp_client::RmcpClient`] per
//! The [`McpConnectionManager`] owns one [`llmx_rmcp_client::RmcpClient`] per
//! configured server (keyed by the *server name*). It offers convenience
//! helpers to query the available tools across *all* servers and returns them
//! in a single aggregated map using the fully-qualified tool name
@@ -16,8 +16,8 @@ use std::time::Duration;
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use codex_rmcp_client::OAuthCredentialsStoreMode;
use codex_rmcp_client::RmcpClient;
use llmx_rmcp_client::OAuthCredentialsStoreMode;
use llmx_rmcp_client::RmcpClient;
use mcp_types::ClientCapabilities;
use mcp_types::Implementation;
use mcp_types::ListResourceTemplatesRequestParams;

4
llmx-rs/core/src/mcp_tool_call.rs
View File

@@ -8,8 +8,8 @@ use crate::protocol::EventMsg;
use crate::protocol::McpInvocation;
use crate::protocol::McpToolCallBeginEvent;
use crate::protocol::McpToolCallEndEvent;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseInputItem;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseInputItem;
/// Handles the specified tool call dispatches the appropriate
/// `McpToolCallBegin` and `McpToolCallEnd` events to the `Session`.

2
llmx-rs/core/src/message_history.rs
View File

@@ -30,7 +30,7 @@ use tokio::io::AsyncReadExt;
use crate::config::Config;
use crate::config::types::HistoryPersistence;
use codex_protocol::ConversationId;
use llmx_protocol::ConversationId;
#[cfg(unix)]
use std::os::unix::fs::OpenOptionsExt;
#[cfg(unix)]

2
llmx-rs/core/src/model_provider_info.rs
View File

@@ -8,7 +8,7 @@
use crate::CodexAuth;
use crate::default_client::CodexHttpClient;
use crate::default_client::CodexRequestBuilder;
use codex_app_server_protocol::AuthMode;
use llmx_app_server_protocol::AuthMode;
use serde::Deserialize;
use serde::Serialize;
use std::collections::HashMap;

8
llmx-rs/core/src/otel_init.rs
View File

@@ -2,10 +2,10 @@ use crate::config::Config;
use crate::config::types::OtelExporterKind as Kind;
use crate::config::types::OtelHttpProtocol as Protocol;
use crate::default_client::originator;
use codex_otel::config::OtelExporter;
use codex_otel::config::OtelHttpProtocol;
use codex_otel::config::OtelSettings;
use codex_otel::otel_provider::OtelProvider;
use llmx_otel::config::OtelExporter;
use llmx_otel::config::OtelHttpProtocol;
use llmx_otel::config::OtelSettings;
use llmx_otel::otel_provider::OtelProvider;
use std::error::Error;
/// Build an OpenTelemetry provider from the app Config.

2
llmx-rs/core/src/parse_command.rs
View File

@@ -1,7 +1,7 @@
use crate::bash::extract_bash_command;
use crate::bash::try_parse_shell;
use crate::bash::try_parse_word_only_commands_sequence;
use codex_protocol::parse_command::ParsedCommand;
use llmx_protocol::parse_command::ParsedCommand;
use shlex::split as shlex_split;
use shlex::try_join as shlex_try_join;
use std::path::PathBuf;

6
llmx-rs/core/src/response_processing.rs
View File

@@ -1,8 +1,8 @@
use crate::codex::Session;
use crate::codex::TurnContext;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseInputItem;
use llmx_protocol::models::ResponseItem;
use tracing::warn;
/// Process streamed `ResponseItem`s from the model into the pair of:

8
llmx-rs/core/src/rollout/list.rs
View File

@@ -14,10 +14,10 @@ use uuid::Uuid;
use super::SESSIONS_SUBDIR;
use crate::protocol::EventMsg;
use codex_file_search as file_search;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::RolloutLine;
use codex_protocol::protocol::SessionSource;
use llmx_file_search as file_search;
use llmx_protocol::protocol::RolloutItem;
use llmx_protocol::protocol::RolloutLine;
use llmx_protocol::protocol::SessionSource;
/// Returned page of conversation summaries.
#[derive(Debug, Default, PartialEq)]

4
llmx-rs/core/src/rollout/mod.rs
View File

@@ -1,6 +1,6 @@
//! Rollout module: persistence and discovery of session rollout files.
use codex_protocol::protocol::SessionSource;
use llmx_protocol::protocol::SessionSource;
pub const SESSIONS_SUBDIR: &str = "sessions";
pub const ARCHIVED_SESSIONS_SUBDIR: &str = "archived_sessions";
@@ -11,7 +11,7 @@ pub mod list;
pub(crate) mod policy;
pub mod recorder;
pub use codex_protocol::protocol::SessionMeta;
pub use llmx_protocol::protocol::SessionMeta;
pub use list::find_conversation_path_by_id_str;
pub use recorder::RolloutRecorder;
pub use recorder::RolloutRecorderParams;

2
llmx-rs/core/src/rollout/policy.rs
View File

@@ -1,6 +1,6 @@
use crate::protocol::EventMsg;
use crate::protocol::RolloutItem;
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::ResponseItem;
/// Whether a rollout `item` should be persisted in rollout files.
#[inline]

16
llmx-rs/core/src/rollout/recorder.rs
View File

@@ -6,7 +6,7 @@ use std::io::Error as IoError;
use std::path::Path;
use std::path::PathBuf;
use codex_protocol::ConversationId;
use llmx_protocol::ConversationId;
use serde_json::Value;
use time::OffsetDateTime;
use time::format_description::FormatItem;
@@ -26,13 +26,13 @@ use super::policy::is_persisted_response_item;
use crate::config::Config;
use crate::default_client::originator;
use crate::git_info::collect_git_info;
use codex_protocol::protocol::InitialHistory;
use codex_protocol::protocol::ResumedHistory;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::RolloutLine;
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
use llmx_protocol::protocol::InitialHistory;
use llmx_protocol::protocol::ResumedHistory;
use llmx_protocol::protocol::RolloutItem;
use llmx_protocol::protocol::RolloutLine;
use llmx_protocol::protocol::SessionMeta;
use llmx_protocol::protocol::SessionMetaLine;
use llmx_protocol::protocol::SessionSource;
/// Records all [`ResponseItem`]s for a session and flushes them to disk after
/// every update.

22
llmx-rs/core/src/rollout/tests.rs
View File

@@ -19,17 +19,17 @@ use crate::rollout::list::Cursor;
use crate::rollout::list::get_conversation;
use crate::rollout::list::get_conversations;
use anyhow::Result;
use codex_protocol::ConversationId;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::CompactedItem;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::RolloutLine;
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::UserMessageEvent;
use llmx_protocol::ConversationId;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::CompactedItem;
use llmx_protocol::protocol::EventMsg;
use llmx_protocol::protocol::RolloutItem;
use llmx_protocol::protocol::RolloutLine;
use llmx_protocol::protocol::SessionMeta;
use llmx_protocol::protocol::SessionMetaLine;
use llmx_protocol::protocol::SessionSource;
use llmx_protocol::protocol::UserMessageEvent;
const NO_SOURCE_FILTER: &[SessionSource] = &[];
const TEST_PROVIDER: &str = "test-provider";

4
llmx-rs/core/src/safety.rs
View File

@@ -2,8 +2,8 @@ use std::path::Component;
use std::path::Path;
use std::path::PathBuf;
use codex_apply_patch::ApplyPatchAction;
use codex_apply_patch::ApplyPatchFileChange;
use llmx_apply_patch::ApplyPatchAction;
use llmx_apply_patch::ApplyPatchFileChange;
use crate::exec::SandboxType;

12
llmx-rs/core/src/sandboxing/assessment.rs
View File

@@ -12,12 +12,12 @@ use crate::client_common::ResponseEvent;
use crate::config::Config;
use crate::protocol::SandboxPolicy;
use askama::Template;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::ConversationId;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::SandboxCommandAssessment;
use codex_protocol::protocol::SessionSource;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::ConversationId;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::SandboxCommandAssessment;
use llmx_protocol::protocol::SessionSource;
use futures::StreamExt;
use serde_json::json;
use tokio::time::timeout;

2
llmx-rs/core/src/state/service.rs
View File

@@ -6,7 +6,7 @@ use crate::mcp_connection_manager::McpConnectionManager;
use crate::tools::sandboxing::ApprovalStore;
use crate::unified_exec::UnifiedExecSessionManager;
use crate::user_notification::UserNotifier;
use codex_otel::otel_event_manager::OtelEventManager;
use llmx_otel::otel_event_manager::OtelEventManager;
use tokio::sync::Mutex;
pub(crate) struct SessionServices {

2
llmx-rs/core/src/state/session.rs
View File

@@ -1,6 +1,6 @@
//! Session-wide mutable state.
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::ResponseItem;
use crate::codex::SessionConfiguration;
use crate::context_manager::ContextManager;

2
llmx-rs/core/src/state/turn.rs
View File

@@ -8,7 +8,7 @@ use tokio::sync::Notify;
use tokio_util::sync::CancellationToken;
use tokio_util::task::AbortOnDropHandle;
use codex_protocol::models::ResponseInputItem;
use llmx_protocol::models::ResponseInputItem;
use tokio::sync::oneshot;
use crate::codex::TurnContext;

2
llmx-rs/core/src/tasks/compact.rs
View File

@@ -6,7 +6,7 @@ use tokio_util::sync::CancellationToken;
use crate::codex::TurnContext;
use crate::compact;
use crate::state::TaskKind;
use codex_protocol::user_input::UserInput;
use llmx_protocol::user_input::UserInput;
use super::SessionTask;
use super::SessionTaskContext;

14
llmx-rs/core/src/tasks/ghost_snapshot.rs
View File

@@ -3,13 +3,13 @@ use crate::state::TaskKind;
use crate::tasks::SessionTask;
use crate::tasks::SessionTaskContext;
use async_trait::async_trait;
use codex_git::CreateGhostCommitOptions;
use codex_git::GitToolingError;
use codex_git::create_ghost_commit;
use codex_protocol::models::ResponseItem;
use codex_protocol::user_input::UserInput;
use codex_utils_readiness::Readiness;
use codex_utils_readiness::Token;
use llmx_git::CreateGhostCommitOptions;
use llmx_git::GitToolingError;
use llmx_git::create_ghost_commit;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::user_input::UserInput;
use llmx_utils_readiness::Readiness;
use llmx_utils_readiness::Token;
use std::sync::Arc;
use tokio_util::sync::CancellationToken;
use tracing::info;

2
llmx-rs/core/src/tasks/mod.rs
View File

@@ -26,7 +26,7 @@ use crate::protocol::TurnAbortedEvent;
use crate::state::ActiveTurn;
use crate::state::RunningTask;
use crate::state::TaskKind;
use codex_protocol::user_input::UserInput;
use llmx_protocol::user_input::UserInput;
pub(crate) use compact::CompactTask;
pub(crate) use ghost_snapshot::GhostSnapshotTask;

2
llmx-rs/core/src/tasks/regular.rs
View File

@@ -6,7 +6,7 @@ use tokio_util::sync::CancellationToken;
use crate::codex::TurnContext;
use crate::codex::run_task;
use crate::state::TaskKind;
use codex_protocol::user_input::UserInput;
use llmx_protocol::user_input::UserInput;
use super::SessionTask;
use super::SessionTaskContext;

26
llmx-rs/core/src/tasks/review.rs
View File

@@ -1,24 +1,24 @@
use std::sync::Arc;
use async_trait::async_trait;
use codex_protocol::items::TurnItem;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::AgentMessageContentDeltaEvent;
use codex_protocol::protocol::AgentMessageDeltaEvent;
use codex_protocol::protocol::Event;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ExitedReviewModeEvent;
use codex_protocol::protocol::ItemCompletedEvent;
use codex_protocol::protocol::ReviewOutputEvent;
use llmx_protocol::items::TurnItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::protocol::AgentMessageContentDeltaEvent;
use llmx_protocol::protocol::AgentMessageDeltaEvent;
use llmx_protocol::protocol::Event;
use llmx_protocol::protocol::EventMsg;
use llmx_protocol::protocol::ExitedReviewModeEvent;
use llmx_protocol::protocol::ItemCompletedEvent;
use llmx_protocol::protocol::ReviewOutputEvent;
use tokio_util::sync::CancellationToken;
use crate::codex::Session;
use crate::codex::TurnContext;
use crate::codex_delegate::run_codex_conversation_one_shot;
use crate::llmx_delegate::run_llmx_conversation_one_shot;
use crate::review_format::format_review_findings_block;
use crate::state::TaskKind;
use codex_protocol::user_input::UserInput;
use llmx_protocol::user_input::UserInput;
use super::SessionTask;
use super::SessionTaskContext;
@@ -83,7 +83,7 @@ async fn start_review_conversation(
// Set explicit review rubric for the sub-agent
sub_agent_config.base_instructions = Some(crate::REVIEW_PROMPT.to_string());
(run_codex_conversation_one_shot(
(run_llmx_conversation_one_shot(
sub_agent_config,
session.auth_manager(),
input,

6
llmx-rs/core/src/tasks/undo.rs
View File

@@ -8,9 +8,9 @@ use crate::state::TaskKind;
use crate::tasks::SessionTask;
use crate::tasks::SessionTaskContext;
use async_trait::async_trait;
use codex_git::restore_ghost_commit;
use codex_protocol::models::ResponseItem;
use codex_protocol::user_input::UserInput;
use llmx_git::restore_ghost_commit;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::user_input::UserInput;
use tokio_util::sync::CancellationToken;
use tracing::error;
use tracing::info;

6
llmx-rs/core/src/tasks/user_shell.rs
View File

@@ -2,9 +2,9 @@ use std::sync::Arc;
use std::time::Duration;
use async_trait::async_trait;
use codex_async_utils::CancelErr;
use codex_async_utils::OrCancelExt;
use codex_protocol::user_input::UserInput;
use llmx_async_utils::CancelErr;
use llmx_async_utils::OrCancelExt;
use llmx_protocol::user_input::UserInput;
use tokio_util::sync::CancellationToken;
use tracing::error;
use uuid::Uuid;

14
llmx-rs/core/src/tools/context.rs
View File

@@ -4,13 +4,13 @@ use crate::tools::TELEMETRY_PREVIEW_MAX_BYTES;
use crate::tools::TELEMETRY_PREVIEW_MAX_LINES;
use crate::tools::TELEMETRY_PREVIEW_TRUNCATION_NOTICE;
use crate::turn_diff_tracker::TurnDiffTracker;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::models::FunctionCallOutputContentItem;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ShellToolCallParams;
use codex_protocol::protocol::FileChange;
use codex_utils_string::take_bytes_at_char_boundary;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::models::FunctionCallOutputContentItem;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseInputItem;
use llmx_protocol::models::ShellToolCallParams;
use llmx_protocol::protocol::FileChange;
use llmx_utils_string::take_bytes_at_char_boundary;
use mcp_types::CallToolResult;
use std::borrow::Cow;
use std::collections::HashMap;

10
llmx-rs/core/src/tools/handlers/apply_patch.rs
View File

@@ -73,8 +73,8 @@ impl ToolHandler for ApplyPatchHandler {
// Avoid building temporary ExecParams/command vectors; derive directly from inputs.
let cwd = turn.cwd.clone();
let command = vec!["apply_patch".to_string(), patch_input.clone()];
match codex_apply_patch::maybe_parse_apply_patch_verified(&command, &cwd) {
codex_apply_patch::MaybeApplyPatchVerified::Body(changes) => {
match llmx_apply_patch::maybe_parse_apply_patch_verified(&command, &cwd) {
llmx_apply_patch::MaybeApplyPatchVerified::Body(changes) => {
match apply_patch::apply_patch(session.as_ref(), turn.as_ref(), &call_id, changes)
.await
{
@@ -133,18 +133,18 @@ impl ToolHandler for ApplyPatchHandler {
}
}
}
codex_apply_patch::MaybeApplyPatchVerified::CorrectnessError(parse_error) => {
llmx_apply_patch::MaybeApplyPatchVerified::CorrectnessError(parse_error) => {
Err(FunctionCallError::RespondToModel(format!(
"apply_patch verification failed: {parse_error}"
)))
}
codex_apply_patch::MaybeApplyPatchVerified::ShellParseError(error) => {
llmx_apply_patch::MaybeApplyPatchVerified::ShellParseError(error) => {
tracing::trace!("Failed to parse apply_patch input, {error:?}");
Err(FunctionCallError::RespondToModel(
"apply_patch handler received invalid patch input".to_string(),
))
}
codex_apply_patch::MaybeApplyPatchVerified::NotApplyPatch => {
llmx_apply_patch::MaybeApplyPatchVerified::NotApplyPatch => {
Err(FunctionCallError::RespondToModel(
"apply_patch handler received non-apply_patch input".to_string(),
))

2
llmx-rs/core/src/tools/handlers/list_dir.rs
View File

@@ -5,7 +5,7 @@ use std::path::Path;
use std::path::PathBuf;
use async_trait::async_trait;
use codex_utils_string::take_bytes_at_char_boundary;
use llmx_utils_string::take_bytes_at_char_boundary;
use serde::Deserialize;
use tokio::fs;

6
llmx-rs/core/src/tools/handlers/mcp.rs
View File

@@ -52,11 +52,11 @@ impl ToolHandler for McpHandler {
.await;
match response {
codex_protocol::models::ResponseInputItem::McpToolCallOutput { result, .. } => {
llmx_protocol::models::ResponseInputItem::McpToolCallOutput { result, .. } => {
Ok(ToolOutput::Mcp { result })
}
codex_protocol::models::ResponseInputItem::FunctionCallOutput { output, .. } => {
let codex_protocol::models::FunctionCallOutputPayload {
llmx_protocol::models::ResponseInputItem::FunctionCallOutput { output, .. } => {
let llmx_protocol::models::FunctionCallOutputPayload {
content,
content_items,
success,

4
llmx-rs/core/src/tools/handlers/plan.rs
View File

@@ -10,8 +10,8 @@ use crate::tools::registry::ToolHandler;
use crate::tools::registry::ToolKind;
use crate::tools::spec::JsonSchema;
use async_trait::async_trait;
use codex_protocol::plan_tool::UpdatePlanArgs;
use codex_protocol::protocol::EventMsg;
use llmx_protocol::plan_tool::UpdatePlanArgs;
use llmx_protocol::protocol::EventMsg;
use std::collections::BTreeMap;
use std::sync::LazyLock;

2
llmx-rs/core/src/tools/handlers/read_file.rs
View File

@@ -2,7 +2,7 @@ use std::collections::VecDeque;
use std::path::PathBuf;
use async_trait::async_trait;
use codex_utils_string::take_bytes_at_char_boundary;
use llmx_utils_string::take_bytes_at_char_boundary;
use serde::Deserialize;
use crate::function_tool::FunctionCallError;

14
llmx-rs/core/src/tools/handlers/shell.rs
View File

@@ -1,5 +1,5 @@
use async_trait::async_trait;
use codex_protocol::models::ShellToolCallParams;
use llmx_protocol::models::ShellToolCallParams;
use std::sync::Arc;
use crate::apply_patch;
@@ -116,7 +116,7 @@ impl ShellHandler {
if exec_params.with_escalated_permissions.unwrap_or(false)
&& !matches!(
turn.approval_policy,
codex_protocol::protocol::AskForApproval::OnRequest
llmx_protocol::protocol::AskForApproval::OnRequest
)
{
return Err(FunctionCallError::RespondToModel(format!(
@@ -126,11 +126,11 @@ impl ShellHandler {
}
// Intercept apply_patch if present.
match codex_apply_patch::maybe_parse_apply_patch_verified(
match llmx_apply_patch::maybe_parse_apply_patch_verified(
&exec_params.command,
&exec_params.cwd,
) {
codex_apply_patch::MaybeApplyPatchVerified::Body(changes) => {
llmx_apply_patch::MaybeApplyPatchVerified::Body(changes) => {
match apply_patch::apply_patch(session.as_ref(), turn.as_ref(), &call_id, changes)
.await
{
@@ -189,16 +189,16 @@ impl ShellHandler {
}
}
}
codex_apply_patch::MaybeApplyPatchVerified::CorrectnessError(parse_error) => {
llmx_apply_patch::MaybeApplyPatchVerified::CorrectnessError(parse_error) => {
return Err(FunctionCallError::RespondToModel(format!(
"apply_patch verification failed: {parse_error}"
)));
}
codex_apply_patch::MaybeApplyPatchVerified::ShellParseError(error) => {
llmx_apply_patch::MaybeApplyPatchVerified::ShellParseError(error) => {
tracing::trace!("Failed to parse shell command, {error:?}");
// Fall through to regular shell execution.
}
codex_apply_patch::MaybeApplyPatchVerified::NotApplyPatch => {
llmx_apply_patch::MaybeApplyPatchVerified::NotApplyPatch => {
// Fall through to regular shell execution.
}
}

2
llmx-rs/core/src/tools/handlers/view_image.rs
View File

@@ -10,7 +10,7 @@ use crate::tools::context::ToolOutput;
use crate::tools::context::ToolPayload;
use crate::tools::registry::ToolHandler;
use crate::tools::registry::ToolKind;
use codex_protocol::user_input::UserInput;
use llmx_protocol::user_input::UserInput;
pub struct ViewImageHandler;

8
llmx-rs/core/src/tools/orchestrator.rs
View File

@@ -16,8 +16,8 @@ use crate::tools::sandboxing::SandboxAttempt;
use crate::tools::sandboxing::ToolCtx;
use crate::tools::sandboxing::ToolError;
use crate::tools::sandboxing::ToolRuntime;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::ReviewDecision;
use llmx_protocol::protocol::AskForApproval;
use llmx_protocol::protocol::ReviewDecision;
pub(crate) struct ToolOrchestrator {
sandbox: SandboxManager,
@@ -45,8 +45,8 @@ impl ToolOrchestrator {
let otel = turn_ctx.client.get_otel_event_manager();
let otel_tn = &tool_ctx.tool_name;
let otel_ci = &tool_ctx.call_id;
let otel_user = codex_otel::otel_event_manager::ToolDecisionSource::User;
let otel_cfg = codex_otel::otel_event_manager::ToolDecisionSource::Config;
let otel_user = llmx_otel::otel_event_manager::ToolDecisionSource::User;
let otel_cfg = llmx_otel::otel_event_manager::ToolDecisionSource::Config;
// 1) Approval
let needs_initial_approval =

6
llmx-rs/core/src/tools/parallel.rs
View File

@@ -14,9 +14,9 @@ use crate::tools::context::SharedTurnDiffTracker;
use crate::tools::context::ToolPayload;
use crate::tools::router::ToolCall;
use crate::tools::router::ToolRouter;
use codex_protocol::models::FunctionCallOutputPayload;
use codex_protocol::models::ResponseInputItem;
use codex_utils_readiness::Readiness;
use llmx_protocol::models::FunctionCallOutputPayload;
use llmx_protocol::models::ResponseInputItem;
use llmx_utils_readiness::Readiness;
pub(crate) struct ToolCallRuntime {
router: Arc<ToolRouter>,

2
llmx-rs/core/src/tools/registry.rs
View File

@@ -3,7 +3,7 @@ use std::sync::Arc;
use std::time::Duration;
use async_trait::async_trait;
use codex_protocol::models::ResponseInputItem;
use llmx_protocol::models::ResponseInputItem;
use tracing::warn;
use crate::client_common::tools::ToolSpec;

10
llmx-rs/core/src/tools/router.rs
View File

@@ -12,10 +12,10 @@ use crate::tools::registry::ConfiguredToolSpec;
use crate::tools::registry::ToolRegistry;
use crate::tools::spec::ToolsConfig;
use crate::tools::spec::build_specs;
use codex_protocol::models::LocalShellAction;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::models::ShellToolCallParams;
use llmx_protocol::models::LocalShellAction;
use llmx_protocol::models::ResponseInputItem;
use llmx_protocol::models::ResponseItem;
use llmx_protocol::models::ShellToolCallParams;
#[derive(Clone)]
pub struct ToolCall {
@@ -178,7 +178,7 @@ impl ToolRouter {
} else {
ResponseInputItem::FunctionCallOutput {
call_id,
output: codex_protocol::models::FunctionCallOutputPayload {
output: llmx_protocol::models::FunctionCallOutputPayload {
content: message,
success: Some(false),
..Default::default()

4
llmx-rs/core/src/tools/runtimes/apply_patch.rs
View File

@@ -19,8 +19,8 @@ use crate::tools::sandboxing::ToolCtx;
use crate::tools::sandboxing::ToolError;
use crate::tools::sandboxing::ToolRuntime;
use crate::tools::sandboxing::with_cached_approval;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::ReviewDecision;
use llmx_protocol::protocol::AskForApproval;
use llmx_protocol::protocol::ReviewDecision;
use futures::future::BoxFuture;
use std::collections::HashMap;
use std::path::PathBuf;

4
llmx-rs/core/src/tools/runtimes/shell.rs
View File

@@ -20,8 +20,8 @@ use crate::tools::sandboxing::ToolCtx;
use crate::tools::sandboxing::ToolError;
use crate::tools::sandboxing::ToolRuntime;
use crate::tools::sandboxing::with_cached_approval;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::ReviewDecision;
use llmx_protocol::protocol::AskForApproval;
use llmx_protocol::protocol::ReviewDecision;
use futures::future::BoxFuture;
use std::path::PathBuf;

6
llmx-rs/core/src/tools/runtimes/unified_exec.rs
View File

@@ -22,9 +22,9 @@ use crate::tools::sandboxing::with_cached_approval;
use crate::unified_exec::UnifiedExecError;
use crate::unified_exec::UnifiedExecSession;
use crate::unified_exec::UnifiedExecSessionManager;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::ReviewDecision;
use codex_protocol::protocol::SandboxPolicy;
use llmx_protocol::protocol::AskForApproval;
use llmx_protocol::protocol::ReviewDecision;
use llmx_protocol::protocol::SandboxPolicy;
use futures::future::BoxFuture;
use std::collections::HashMap;
use std::path::PathBuf;

4
llmx-rs/core/src/tools/sandboxing.rs
View File

@@ -13,8 +13,8 @@ use crate::sandboxing::CommandSpec;
use crate::sandboxing::SandboxManager;
use crate::sandboxing::SandboxTransformError;
use crate::state::SessionServices;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::ReviewDecision;
use llmx_protocol::protocol::AskForApproval;
use llmx_protocol::protocol::ReviewDecision;
use std::collections::HashMap;
use std::fmt::Debug;
use std::hash::Hash;

4
llmx-rs/core/src/truncate.rs
View File

@@ -1,7 +1,7 @@
//! Utilities for truncating large chunks of output while preserving a prefix
//! and suffix on UTF-8 boundaries.
use codex_utils_tokenizer::Tokenizer;
use llmx_utils_tokenizer::Tokenizer;
/// Truncate the middle of a UTF-8 string to at most `max_bytes` bytes,
/// preserving the beginning and the end. Returns the possibly truncated
@@ -137,7 +137,7 @@ pub(crate) fn truncate_middle(s: &str, max_bytes: usize) -> (String, Option<u64>
#[cfg(test)]
mod tests {
use super::truncate_middle;
use codex_utils_tokenizer::Tokenizer;
use llmx_utils_tokenizer::Tokenizer;
#[test]
fn truncate_middle_no_newlines_fallback() {

4
llmx-rs/core/src/unified_exec/session.rs
View File

@@ -15,8 +15,8 @@ use crate::exec::SandboxType;
use crate::exec::StreamOutput;
use crate::exec::is_likely_sandbox_denied;
use crate::truncate::truncate_middle;
use codex_utils_pty::ExecCommandSession;
use codex_utils_pty::SpawnedPty;
use llmx_utils_pty::ExecCommandSession;
use llmx_utils_pty::SpawnedPty;
use super::UNIFIED_EXEC_OUTPUT_MAX_BYTES;
use super::UnifiedExecError;

2
llmx-rs/core/src/unified_exec/session_manager.rs
View File

@@ -301,7 +301,7 @@ impl UnifiedExecSessionManager {
.split_first()
.ok_or(UnifiedExecError::MissingCommandLine)?;
let spawned = codex_utils_pty::spawn_pty_process(
let spawned = llmx_utils_pty::spawn_pty_process(
program,
args,
env.cwd.as_path(),

4
llmx-rs/core/src/user_instructions.rs
View File

@@ -1,8 +1,8 @@
use serde::Deserialize;
use serde::Serialize;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
pub const USER_INSTRUCTIONS_OPEN_TAG_LEGACY: &str = "<user_instructions>";
pub const USER_INSTRUCTIONS_PREFIX: &str = "# AGENTS.md instructions for ";

4
llmx-rs/core/src/user_shell_command.rs
View File

@@ -1,7 +1,7 @@
use std::time::Duration;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use llmx_protocol::models::ContentItem;
use llmx_protocol::models::ResponseItem;
use crate::exec::ExecToolCallOutput;
use crate::tools::format_exec_output_str;

30
llmx-rs/core/tests/chat_completions_payload.rs
View File

@@ -1,19 +1,19 @@
use std::sync::Arc;
use codex_app_server_protocol::AuthMode;
use codex_core::ContentItem;
use codex_core::LocalShellAction;
use codex_core::LocalShellExecAction;
use codex_core::LocalShellStatus;
use codex_core::ModelClient;
use codex_core::ModelProviderInfo;
use codex_core::Prompt;
use codex_core::ResponseItem;
use codex_core::WireApi;
use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::ConversationId;
use codex_protocol::models::ReasoningItemContent;
use llmx_app_server_protocol::AuthMode;
use llmx_core::ContentItem;
use llmx_core::LocalShellAction;
use llmx_core::LocalShellExecAction;
use llmx_core::LocalShellStatus;
use llmx_core::ModelClient;
use llmx_core::ModelProviderInfo;
use llmx_core::Prompt;
use llmx_core::ResponseItem;
use llmx_core::WireApi;
use llmx_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::ConversationId;
use llmx_protocol::models::ReasoningItemContent;
use core_test_support::load_default_config_for_test;
use futures::StreamExt;
use serde_json::Value;
@@ -94,7 +94,7 @@ async fn run_request(input: Vec<ResponseItem>) -> Value {
effort,
summary,
conversation_id,
codex_protocol::protocol::SessionSource::Exec,
llmx_protocol::protocol::SessionSource::Exec,
);
let mut prompt = Prompt::default();

26
llmx-rs/core/tests/chat_completions_sse.rs
View File

@@ -2,18 +2,18 @@ use assert_matches::assert_matches;
use std::sync::Arc;
use tracing_test::traced_test;
use codex_app_server_protocol::AuthMode;
use codex_core::ContentItem;
use codex_core::ModelClient;
use codex_core::ModelProviderInfo;
use codex_core::Prompt;
use codex_core::ResponseEvent;
use codex_core::ResponseItem;
use codex_core::WireApi;
use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::ConversationId;
use codex_protocol::models::ReasoningItemContent;
use llmx_app_server_protocol::AuthMode;
use llmx_core::ContentItem;
use llmx_core::ModelClient;
use llmx_core::ModelProviderInfo;
use llmx_core::Prompt;
use llmx_core::ResponseEvent;
use llmx_core::ResponseItem;
use llmx_core::WireApi;
use llmx_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::ConversationId;
use llmx_protocol::models::ReasoningItemContent;
use core_test_support::load_default_config_for_test;
use futures::StreamExt;
use tempfile::TempDir;
@@ -94,7 +94,7 @@ async fn run_stream_with_bytes(sse_body: &[u8]) -> Vec<ResponseEvent> {
effort,
summary,
conversation_id,
codex_protocol::protocol::SessionSource::Exec,
llmx_protocol::protocol::SessionSource::Exec,
);
let mut prompt = Prompt::default();

4
llmx-rs/core/tests/common/Cargo.toml
View File

@@ -9,8 +9,8 @@ path = "lib.rs"
[dependencies]
anyhow = { workspace = true }
assert_cmd = { workspace = true }
codex-core = { workspace = true }
codex-protocol = { workspace = true }
llmx-core = { workspace = true }
llmx-protocol = { workspace = true }
notify = { workspace = true }
regex-lite = { workspace = true }
serde_json = { workspace = true }

22
llmx-rs/core/tests/common/lib.rs
View File

@@ -2,10 +2,10 @@
use tempfile::TempDir;
use codex_core::CodexConversation;
use codex_core::config::Config;
use codex_core::config::ConfigOverrides;
use codex_core::config::ConfigToml;
use llmx_core::CodexConversation;
use llmx_core::config::Config;
use llmx_core::config::ConfigOverrides;
use llmx_core::config::ConfigToml;
use regex_lite::Regex;
#[cfg(target_os = "linux")]
@@ -126,9 +126,9 @@ pub fn load_sse_fixture_with_id(path: impl AsRef<std::path::Path>, id: &str) ->
pub async fn wait_for_event<F>(
codex: &CodexConversation,
predicate: F,
) -> codex_core::protocol::EventMsg
) -> llmx_core::protocol::EventMsg
where
F: FnMut(&codex_core::protocol::EventMsg) -> bool,
F: FnMut(&llmx_core::protocol::EventMsg) -> bool,
{
use tokio::time::Duration;
wait_for_event_with_timeout(codex, predicate, Duration::from_secs(1)).await
@@ -136,7 +136,7 @@ where
pub async fn wait_for_event_match<T, F>(codex: &CodexConversation, matcher: F) -> T
where
F: Fn(&codex_core::protocol::EventMsg) -> Option<T>,
F: Fn(&llmx_core::protocol::EventMsg) -> Option<T>,
{
let ev = wait_for_event(codex, |ev| matcher(ev).is_some()).await;
matcher(&ev).unwrap()
@@ -146,9 +146,9 @@ pub async fn wait_for_event_with_timeout<F>(
codex: &CodexConversation,
mut predicate: F,
wait_time: tokio::time::Duration,
) -> codex_core::protocol::EventMsg
) -> llmx_core::protocol::EventMsg
where
F: FnMut(&codex_core::protocol::EventMsg) -> bool,
F: FnMut(&llmx_core::protocol::EventMsg) -> bool,
{
use tokio::time::Duration;
use tokio::time::timeout;
@@ -165,11 +165,11 @@ where
}
pub fn sandbox_env_var() -> &'static str {
codex_core::spawn::CODEX_SANDBOX_ENV_VAR
llmx_core::spawn::CODEX_SANDBOX_ENV_VAR
}
pub fn sandbox_network_env_var() -> &'static str {
codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR
llmx_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR
}
pub mod fs_wait {

30
llmx-rs/core/tests/common/test_codex.rs
View File

@@ -4,20 +4,20 @@ use std::path::PathBuf;
use std::sync::Arc;
use anyhow::Result;
use codex_core::CodexAuth;
use codex_core::CodexConversation;
use codex_core::ConversationManager;
use codex_core::ModelProviderInfo;
use codex_core::built_in_model_providers;
use codex_core::config::Config;
use codex_core::features::Feature;
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_core::protocol::SessionConfiguredEvent;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::user_input::UserInput;
use llmx_core::CodexAuth;
use llmx_core::CodexConversation;
use llmx_core::ConversationManager;
use llmx_core::ModelProviderInfo;
use llmx_core::built_in_model_providers;
use llmx_core::config::Config;
use llmx_core::features::Feature;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_core::protocol::SessionConfiguredEvent;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::user_input::UserInput;
use serde_json::Value;
use tempfile::TempDir;
use wiremock::MockServer;
@@ -66,7 +66,7 @@ impl TestCodexBuilder {
let new_conversation = match resume_from {
Some(path) => {
let auth_manager = codex_core::AuthManager::from_auth_for_testing(
let auth_manager = llmx_core::AuthManager::from_auth_for_testing(
CodexAuth::from_api_key("dummy"),
);
conversation_manager

2
llmx-rs/core/tests/common/test_codex_exec.rs
View File

@@ -1,5 +1,5 @@
#![allow(clippy::expect_used)]
use codex_core::auth::CODEX_API_KEY_ENV_VAR;
use llmx_core::auth::CODEX_API_KEY_ENV_VAR;
use std::path::Path;
use tempfile::TempDir;
use wiremock::MockServer;

26
llmx-rs/core/tests/responses_headers.rs
View File

@@ -1,16 +1,16 @@
use std::sync::Arc;
use codex_app_server_protocol::AuthMode;
use codex_core::ContentItem;
use codex_core::ModelClient;
use codex_core::ModelProviderInfo;
use codex_core::Prompt;
use codex_core::ResponseEvent;
use codex_core::ResponseItem;
use codex_core::WireApi;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::ConversationId;
use codex_protocol::protocol::SessionSource;
use llmx_app_server_protocol::AuthMode;
use llmx_core::ContentItem;
use llmx_core::ModelClient;
use llmx_core::ModelProviderInfo;
use llmx_core::Prompt;
use llmx_core::ResponseEvent;
use llmx_core::ResponseItem;
use llmx_core::WireApi;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::ConversationId;
use llmx_protocol::protocol::SessionSource;
use core_test_support::load_default_config_for_test;
use core_test_support::responses;
use futures::StreamExt;
@@ -79,7 +79,7 @@ async fn responses_stream_includes_subagent_header_on_review() {
effort,
summary,
conversation_id,
SessionSource::SubAgent(codex_protocol::protocol::SubAgentSource::Review),
SessionSource::SubAgent(llmx_protocol::protocol::SubAgentSource::Review),
);
let mut prompt = Prompt::default();
@@ -167,7 +167,7 @@ async fn responses_stream_includes_subagent_header_on_other() {
effort,
summary,
conversation_id,
SessionSource::SubAgent(codex_protocol::protocol::SubAgentSource::Other(
SessionSource::SubAgent(llmx_protocol::protocol::SubAgentSource::Other(
"my-task".to_string(),
)),
);

6
llmx-rs/core/tests/suite/abort_tasks.rs
View File

@@ -2,9 +2,9 @@ use assert_matches::assert_matches;
use std::sync::Arc;
use std::time::Duration;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_protocol::user_input::UserInput;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_protocol::user_input::UserInput;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_function_call;
use core_test_support::responses::ev_response_created;

18
llmx-rs/core/tests/suite/apply_patch_cli.rs
View File

@@ -4,15 +4,15 @@ use anyhow::Result;
use pretty_assertions::assert_eq;
use std::fs;
use codex_core::config::Config;
use codex_core::features::Feature;
use codex_core::model_family::find_family_for_model;
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::user_input::UserInput;
use llmx_core::config::Config;
use llmx_core::features::Feature;
use llmx_core::model_family::find_family_for_model;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::user_input::UserInput;
use core_test_support::assert_regex_match;
use core_test_support::responses::ev_apply_patch_function_call;
use core_test_support::responses::ev_assistant_message;

18
llmx-rs/core/tests/suite/apply_patch_freeform.rs
View File

@@ -5,15 +5,15 @@ use core_test_support::responses::ev_apply_patch_custom_tool_call;
use pretty_assertions::assert_eq;
use std::fs;
use codex_core::config::Config;
use codex_core::features::Feature;
use codex_core::model_family::find_family_for_model;
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::user_input::UserInput;
use llmx_core::config::Config;
use llmx_core::features::Feature;
use llmx_core::model_family::find_family_for_model;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::user_input::UserInput;
use core_test_support::assert_regex_match;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;

22
llmx-rs/core/tests/suite/approvals.rs
View File

@@ -1,17 +1,17 @@
#![allow(clippy::unwrap_used, clippy::expect_used)]
use anyhow::Result;
use codex_core::features::Feature;
use codex_core::model_family::find_family_for_model;
use codex_core::protocol::ApplyPatchApprovalRequestEvent;
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::ExecApprovalRequestEvent;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::protocol::ReviewDecision;
use codex_protocol::user_input::UserInput;
use llmx_core::features::Feature;
use llmx_core::model_family::find_family_for_model;
use llmx_core::protocol::ApplyPatchApprovalRequestEvent;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::ExecApprovalRequestEvent;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::protocol::ReviewDecision;
use llmx_protocol::user_input::UserInput;
use core_test_support::responses::ev_apply_patch_function_call;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;

20
llmx-rs/core/tests/suite/auth_refresh.rs
View File

@@ -3,16 +3,16 @@ use anyhow::Result;
use base64::Engine;
use chrono::Duration;
use chrono::Utc;
use codex_core::CodexAuth;
use codex_core::auth::AuthCredentialsStoreMode;
use codex_core::auth::AuthDotJson;
use codex_core::auth::REFRESH_TOKEN_URL_OVERRIDE_ENV_VAR;
use codex_core::auth::RefreshTokenError;
use codex_core::auth::load_auth_dot_json;
use codex_core::auth::save_auth;
use codex_core::error::RefreshTokenFailedReason;
use codex_core::token_data::IdTokenInfo;
use codex_core::token_data::TokenData;
use llmx_core::CodexAuth;
use llmx_core::auth::AuthCredentialsStoreMode;
use llmx_core::auth::AuthDotJson;
use llmx_core::auth::REFRESH_TOKEN_URL_OVERRIDE_ENV_VAR;
use llmx_core::auth::RefreshTokenError;
use llmx_core::auth::load_auth_dot_json;
use llmx_core::auth::save_auth;
use llmx_core::error::RefreshTokenFailedReason;
use llmx_core::token_data::IdTokenInfo;
use llmx_core::token_data::TokenData;
use core_test_support::skip_if_no_network;
use pretty_assertions::assert_eq;
use serde::Serialize;

6
llmx-rs/core/tests/suite/cli_stream.rs
View File

@@ -1,7 +1,7 @@
use assert_cmd::Command as AssertCommand;
use assert_cmd::cargo::cargo_bin;
use codex_core::RolloutRecorder;
use codex_core::protocol::GitInfo;
use llmx_core::RolloutRecorder;
use llmx_core::protocol::GitInfo;
use core_test_support::fs_wait;
use core_test_support::skip_if_no_network;
use std::time::Duration;
@@ -471,7 +471,7 @@ async fn integration_git_info_unit_test() {
.unwrap();
// 3. Test git info collection directly
let git_info = codex_core::git_info::collect_git_info(&git_repo).await;
let git_info = llmx_core::git_info::collect_git_info(&git_repo).await;
// 4. Verify git info is present and contains expected data
assert!(git_info.is_some(), "Git info should be collected");

72
llmx-rs/core/tests/suite/client.rs
View File

@@ -1,30 +1,30 @@
use codex_app_server_protocol::AuthMode;
use codex_core::CodexAuth;
use codex_core::ContentItem;
use codex_core::ConversationManager;
use codex_core::LocalShellAction;
use codex_core::LocalShellExecAction;
use codex_core::LocalShellStatus;
use codex_core::ModelClient;
use codex_core::ModelProviderInfo;
use codex_core::NewConversation;
use codex_core::Prompt;
use codex_core::ResponseEvent;
use codex_core::ResponseItem;
use codex_core::WireApi;
use codex_core::auth::AuthCredentialsStoreMode;
use codex_core::built_in_model_providers;
use codex_core::error::CodexErr;
use codex_core::model_family::find_family_for_model;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SessionSource;
use codex_otel::otel_event_manager::OtelEventManager;
use codex_protocol::ConversationId;
use codex_protocol::models::ReasoningItemContent;
use codex_protocol::models::ReasoningItemReasoningSummary;
use codex_protocol::models::WebSearchAction;
use codex_protocol::user_input::UserInput;
use llmx_app_server_protocol::AuthMode;
use llmx_core::CodexAuth;
use llmx_core::ContentItem;
use llmx_core::ConversationManager;
use llmx_core::LocalShellAction;
use llmx_core::LocalShellExecAction;
use llmx_core::LocalShellStatus;
use llmx_core::ModelClient;
use llmx_core::ModelProviderInfo;
use llmx_core::NewConversation;
use llmx_core::Prompt;
use llmx_core::ResponseEvent;
use llmx_core::ResponseItem;
use llmx_core::WireApi;
use llmx_core::auth::AuthCredentialsStoreMode;
use llmx_core::built_in_model_providers;
use llmx_core::error::CodexErr;
use llmx_core::model_family::find_family_for_model;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SessionSource;
use llmx_otel::otel_event_manager::OtelEventManager;
use llmx_protocol::ConversationId;
use llmx_protocol::models::ReasoningItemContent;
use llmx_protocol::models::ReasoningItemReasoningSummary;
use llmx_protocol::models::WebSearchAction;
use llmx_protocol::user_input::UserInput;
use core_test_support::load_default_config_for_test;
use core_test_support::load_sse_fixture_with_id;
use core_test_support::responses;
@@ -174,10 +174,10 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
.unwrap();
// Prior item: user message (should be delivered)
let prior_user = codex_protocol::models::ResponseItem::Message {
let prior_user = llmx_protocol::models::ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![codex_protocol::models::ContentItem::InputText {
content: vec![llmx_protocol::models::ContentItem::InputText {
text: "resumed user message".to_string(),
}],
};
@@ -194,10 +194,10 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
.unwrap();
// Prior item: system message (excluded from API history)
let prior_system = codex_protocol::models::ResponseItem::Message {
let prior_system = llmx_protocol::models::ResponseItem::Message {
id: None,
role: "system".to_string(),
content: vec![codex_protocol::models::ContentItem::OutputText {
content: vec![llmx_protocol::models::ContentItem::OutputText {
text: "resumed system instruction".to_string(),
}],
};
@@ -214,10 +214,10 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
.unwrap();
// Prior item: assistant message
let prior_item = codex_protocol::models::ResponseItem::Message {
let prior_item = llmx_protocol::models::ResponseItem::Message {
id: None,
role: "assistant".to_string(),
content: vec![codex_protocol::models::ContentItem::OutputText {
content: vec![llmx_protocol::models::ContentItem::OutputText {
text: "resumed assistant message".to_string(),
}],
};
@@ -254,7 +254,7 @@ async fn resume_includes_initial_messages_and_sends_prior_items() {
let conversation_manager =
ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
let auth_manager =
codex_core::AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
llmx_core::AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));
let NewConversation {
conversation: codex,
session_configured,
@@ -539,7 +539,7 @@ async fn prefers_apikey_when_config_prefers_apikey_even_with_chatgpt_tokens() {
let auth_manager =
match CodexAuth::from_auth_storage(codex_home.path(), AuthCredentialsStoreMode::File) {
Ok(Some(auth)) => codex_core::AuthManager::from_auth_for_testing(auth),
Ok(Some(auth)) => llmx_core::AuthManager::from_auth_for_testing(auth),
Ok(None) => panic!("No CodexAuth found in codex_home"),
Err(e) => panic!("Failed to load CodexAuth: {e}"),
};
@@ -754,7 +754,7 @@ async fn azure_responses_request_includes_store_and_reasoning_ids() {
effort,
summary,
conversation_id,
codex_protocol::protocol::SessionSource::Exec,
llmx_protocol::protocol::SessionSource::Exec,
);
let mut prompt = Prompt::default();

26
llmx-rs/core/tests/suite/compact.rs
View File

@@ -1,16 +1,16 @@
use codex_core::CodexAuth;
use codex_core::ConversationManager;
use codex_core::ModelProviderInfo;
use codex_core::NewConversation;
use codex_core::built_in_model_providers;
use codex_core::config::Config;
use codex_core::protocol::ErrorEvent;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::RolloutItem;
use codex_core::protocol::RolloutLine;
use codex_core::protocol::WarningEvent;
use codex_protocol::user_input::UserInput;
use llmx_core::CodexAuth;
use llmx_core::ConversationManager;
use llmx_core::ModelProviderInfo;
use llmx_core::NewConversation;
use llmx_core::built_in_model_providers;
use llmx_core::config::Config;
use llmx_core::protocol::ErrorEvent;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::RolloutItem;
use llmx_core::protocol::RolloutLine;
use llmx_core::protocol::WarningEvent;
use llmx_protocol::user_input::UserInput;
use core_test_support::load_default_config_for_test;
use core_test_support::skip_if_no_network;
use core_test_support::wait_for_event;

28
llmx-rs/core/tests/suite/compact_resume_fork.rs
View File

@@ -11,19 +11,19 @@ use super::compact::COMPACT_WARNING_MESSAGE;
use super::compact::FIRST_REPLY;
use super::compact::SUMMARY_TEXT;
use super::compact::TEST_COMPACT_PROMPT;
use codex_core::CodexAuth;
use codex_core::CodexConversation;
use codex_core::ConversationManager;
use codex_core::ModelProviderInfo;
use codex_core::NewConversation;
use codex_core::built_in_model_providers;
use codex_core::config::Config;
use codex_core::config::OPENAI_DEFAULT_MODEL;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::WarningEvent;
use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
use codex_protocol::user_input::UserInput;
use llmx_core::CodexAuth;
use llmx_core::CodexConversation;
use llmx_core::ConversationManager;
use llmx_core::ModelProviderInfo;
use llmx_core::NewConversation;
use llmx_core::built_in_model_providers;
use llmx_core::config::Config;
use llmx_core::config::OPENAI_DEFAULT_MODEL;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::WarningEvent;
use llmx_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
use llmx_protocol::user_input::UserInput;
use core_test_support::load_default_config_for_test;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
@@ -850,7 +850,7 @@ async fn resume_conversation(
path: std::path::PathBuf,
) -> Arc<CodexConversation> {
let auth_manager =
codex_core::AuthManager::from_auth_for_testing(CodexAuth::from_api_key("dummy"));
llmx_core::AuthManager::from_auth_for_testing(CodexAuth::from_api_key("dummy"));
let NewConversation { conversation, .. } = manager
.resume_conversation_from_rollout(config.clone(), path, auth_manager)
.await

6
llmx-rs/core/tests/suite/deprecation_notice.rs
View File

@@ -1,9 +1,9 @@
#![cfg(not(target_os = "windows"))]
use anyhow::Ok;
use codex_core::features::Feature;
use codex_core::protocol::DeprecationNoticeEvent;
use codex_core::protocol::EventMsg;
use llmx_core::features::Feature;
use llmx_core::protocol::DeprecationNoticeEvent;
use llmx_core::protocol::EventMsg;
use core_test_support::responses::start_mock_server;
use core_test_support::skip_if_no_network;
use core_test_support::test_codex::TestCodex;

16
llmx-rs/core/tests/suite/exec.rs
View File

@@ -3,17 +3,17 @@
use std::collections::HashMap;
use std::string::ToString;
use codex_core::exec::ExecParams;
use codex_core::exec::ExecToolCallOutput;
use codex_core::exec::SandboxType;
use codex_core::exec::process_exec_tool_call;
use codex_core::protocol::SandboxPolicy;
use codex_core::spawn::CODEX_SANDBOX_ENV_VAR;
use llmx_core::exec::ExecParams;
use llmx_core::exec::ExecToolCallOutput;
use llmx_core::exec::SandboxType;
use llmx_core::exec::process_exec_tool_call;
use llmx_core::protocol::SandboxPolicy;
use llmx_core::spawn::CODEX_SANDBOX_ENV_VAR;
use tempfile::TempDir;
use codex_core::error::Result;
use llmx_core::error::Result;
use codex_core::get_platform_sandbox;
use llmx_core::get_platform_sandbox;
fn skip_test() -> bool {
if std::env::var(CODEX_SANDBOX_ENV_VAR) == Ok("seatbelt".to_string()) {

24
llmx-rs/core/tests/suite/fork_conversation.rs
View File

@@ -1,15 +1,15 @@
use codex_core::CodexAuth;
use codex_core::ConversationManager;
use codex_core::ModelProviderInfo;
use codex_core::NewConversation;
use codex_core::built_in_model_providers;
use codex_core::parse_turn_item;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::RolloutItem;
use codex_core::protocol::RolloutLine;
use codex_protocol::items::TurnItem;
use codex_protocol::user_input::UserInput;
use llmx_core::CodexAuth;
use llmx_core::ConversationManager;
use llmx_core::ModelProviderInfo;
use llmx_core::NewConversation;
use llmx_core::built_in_model_providers;
use llmx_core::parse_turn_item;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::RolloutItem;
use llmx_core::protocol::RolloutLine;
use llmx_protocol::items::TurnItem;
use llmx_protocol::user_input::UserInput;
use core_test_support::load_default_config_for_test;
use core_test_support::skip_if_no_network;
use core_test_support::wait_for_event;

14
llmx-rs/core/tests/suite/grep_files.rs
View File

@@ -1,13 +1,13 @@
#![cfg(not(target_os = "windows"))]
use anyhow::Result;
use codex_core::model_family::find_family_for_model;
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::user_input::UserInput;
use llmx_core::model_family::find_family_for_model;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::user_input::UserInput;
use core_test_support::responses;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;

14
llmx-rs/core/tests/suite/items.rs
View File

@@ -1,12 +1,12 @@
#![cfg(not(target_os = "windows"))]
use anyhow::Ok;
use codex_core::protocol::EventMsg;
use codex_core::protocol::ItemCompletedEvent;
use codex_core::protocol::ItemStartedEvent;
use codex_core::protocol::Op;
use codex_protocol::items::TurnItem;
use codex_protocol::user_input::UserInput;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::ItemCompletedEvent;
use llmx_core::protocol::ItemStartedEvent;
use llmx_core::protocol::Op;
use llmx_protocol::items::TurnItem;
use llmx_protocol::user_input::UserInput;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_message_item_added;
@@ -121,7 +121,7 @@ async fn assistant_message_item_is_emitted() -> anyhow::Result<()> {
.await;
assert_eq!(started.id, completed.id);
let Some(codex_protocol::items::AgentMessageContent::Text { text }) = completed.content.first()
let Some(llmx_protocol::items::AgentMessageContent::Text { text }) = completed.content.first()
else {
panic!("expected agent message text content");
};

12
llmx-rs/core/tests/suite/json_result.rs
View File

@@ -1,11 +1,11 @@
#![cfg(not(target_os = "windows"))]
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::user_input::UserInput;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::user_input::UserInput;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
use core_test_support::test_codex::TestCodex;

12
llmx-rs/core/tests/suite/list_dir.rs
View File

@@ -1,11 +1,11 @@
#![cfg(not(target_os = "windows"))]
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::SandboxPolicy;
use codex_protocol::config_types::ReasoningSummary;
use codex_protocol::user_input::UserInput;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::SandboxPolicy;
use llmx_protocol::config_types::ReasoningSummary;
use llmx_protocol::user_input::UserInput;
use core_test_support::responses;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;

18
llmx-rs/core/tests/suite/codex_delegate.rs → llmx-rs/core/tests/suite/llmx_delegate.rs
View File

@@ -1,9 +1,9 @@
use codex_core::protocol::AskForApproval;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol::ReviewDecision;
use codex_core::protocol::ReviewRequest;
use codex_core::protocol::SandboxPolicy;
use llmx_core::protocol::AskForApproval;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol::ReviewDecision;
use llmx_core::protocol::ReviewRequest;
use llmx_core::protocol::SandboxPolicy;
use core_test_support::responses::ev_apply_patch_function_call;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
@@ -22,7 +22,7 @@ use pretty_assertions::assert_eq;
/// Delegate should surface ExecApprovalRequest from sub-agent and proceed
/// after parent submits an approval decision.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn codex_delegate_forwards_exec_approval_and_proceeds_on_approval() {
async fn llmx_delegate_forwards_exec_approval_and_proceeds_on_approval() {
skip_if_no_network!();
// Sub-agent turn 1: emit a shell function_call requiring approval, then complete.
@@ -106,7 +106,7 @@ async fn codex_delegate_forwards_exec_approval_and_proceeds_on_approval() {
/// Delegate should surface ApplyPatchApprovalRequest and honor parent decision
/// so the sub-agent can proceed to completion.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn codex_delegate_forwards_patch_approval_and_proceeds_on_decision() {
async fn llmx_delegate_forwards_patch_approval_and_proceeds_on_decision() {
skip_if_no_network!();
let call_id = "call-patch-1";
@@ -176,7 +176,7 @@ async fn codex_delegate_forwards_patch_approval_and_proceeds_on_decision() {
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn codex_delegate_ignores_legacy_deltas() {
async fn llmx_delegate_ignores_legacy_deltas() {
skip_if_no_network!();
// Single response with reasoning summary deltas.

4
llmx-rs/core/tests/suite/mod.rs
View File

@@ -1,5 +1,5 @@
// Aggregates all former standalone integration tests as modules.
use codex_arg0::arg0_dispatch;
use llmx_arg0::arg0_dispatch;
use ctor::ctor;
use tempfile::TempDir;
@@ -24,7 +24,7 @@ mod approvals;
mod auth_refresh;
mod cli_stream;
mod client;
mod codex_delegate;
mod llmx_delegate;
mod compact;
mod compact_resume_fork;
mod deprecation_notice;

10
llmx-rs/core/tests/suite/model_overrides.rs
View File

@@ -1,8 +1,8 @@
use codex_core::CodexAuth;
use codex_core::ConversationManager;
use codex_core::protocol::EventMsg;
use codex_core::protocol::Op;
use codex_core::protocol_config_types::ReasoningEffort;
use llmx_core::CodexAuth;
use llmx_core::ConversationManager;
use llmx_core::protocol::EventMsg;
use llmx_core::protocol::Op;
use llmx_core::protocol_config_types::ReasoningEffort;
use core_test_support::load_default_config_for_test;
use core_test_support::wait_for_event;
use pretty_assertions::assert_eq;

Some files were not shown because too many files have changed in this diff Show More