Skip to main content

qualia_client_core/api/
chat.rs

1//! Chat sessions
2
3#![allow(non_snake_case)]
4
5use super::*;
6
7use std::path::Path;
8
9/// Creates chat-session.
10pub fn create_chat_session(title: Option<String>) -> Result<String, String> {
11    let state = crate::state::APP_STATE.get().unwrap();
12    let storage = state.config.lock().unwrap().storage_path.clone();
13    crate::chat_session::create_session(Path::new(&storage), title, None).map_err(|e| e.to_string())
14}
15
16/// Lists chat sessions.
17pub fn list_chat_sessions() -> Result<serde_json::Value, String> {
18    let state = crate::state::APP_STATE.get().unwrap();
19    let storage = state.config.lock().unwrap().storage_path.clone();
20    let sessions =
21        crate::chat_session::list_sessions(Path::new(&storage)).map_err(|e| e.to_string())?;
22    serde_json::to_value(sessions).map_err(|e| e.to_string())
23}
24
25/// Loads chat-session.
26pub fn load_chat_session(id: String) -> Result<serde_json::Value, String> {
27    let state = crate::state::APP_STATE.get().unwrap();
28    let storage = state.config.lock().unwrap().storage_path.clone();
29    let session =
30        crate::chat_session::load_session(Path::new(&storage), &id).map_err(|e| e.to_string())?;
31    serde_json::to_value(session).map_err(|e| e.to_string())
32}
33
34/// Appends a chat message.
35pub fn append_chat_message(
36    session_id: String,
37    role: String,
38    content: String,
39) -> Result<u64, String> {
40    append_chat_message_reply(session_id, role, content, None, None)
41}
42
43/// Appends a chat message reply.
44pub fn append_chat_message_reply(
45    session_id: String,
46    role: String,
47    content: String,
48    reply_to_fragment: Option<String>,
49    branch_type_id: Option<String>,
50) -> Result<u64, String> {
51    let state = crate::state::APP_STATE.get().unwrap();
52    let storage = state.config.lock().unwrap().storage_path.clone();
53    let role = crate::chat_session::Role::from_str(&role).map_err(|e| e.to_string())?;
54    crate::chat_session::append_message_with_author(
55        Path::new(&storage),
56        &session_id,
57        role,
58        &content,
59        reply_to_fragment,
60        None,
61        None,
62        None,
63        branch_type_id,
64    )
65    .map_err(|e| e.to_string())
66}
67
68/// Compacts a chat session.
69pub fn compact_chat_session(session_id: String) -> Result<String, String> {
70    let state = crate::state::APP_STATE.get().unwrap();
71    let storage = state.config.lock().unwrap().storage_path.clone();
72    let path = crate::chat_session::compact_session_to_q42(Path::new(&storage), &session_id)
73        .map_err(|e| e.to_string())?;
74    Ok(path.to_string_lossy().into_owned())
75}
76
77/// Deletes a chat session.
78pub fn delete_chat_session(session_id: String) -> Result<(), String> {
79    let state = crate::state::APP_STATE.get().unwrap();
80    let storage = state.config.lock().unwrap().storage_path.clone();
81    crate::chat_session::delete_session(Path::new(&storage), &session_id).map_err(|e| e.to_string())
82}
83
84/// Renames a chat session.
85pub fn rename_chat_session(session_id: String, title: String) -> Result<(), String> {
86    let state = crate::state::APP_STATE.get().unwrap();
87    let storage = state.config.lock().unwrap().storage_path.clone();
88    crate::chat_session::rename_session(Path::new(&storage), &session_id, &title)
89        .map_err(|e| e.to_string())
90}
91
92/// Gets last-chat-session-id.
93pub fn get_last_chat_session_id() -> Option<String> {
94    crate::chat_session::get_last_session_id()
95}
96
97/// Sets last-chat-session-id.
98pub fn set_last_chat_session_id(session_id: String) -> Result<(), String> {
99    crate::chat_session::set_last_session_id(&session_id).map_err(|e| e.to_string())
100}
101
102/// Compiles the session environment.
103pub fn compile_session_environment(session_id: String) -> Result<serde_json::Value, String> {
104    let state = crate::state::APP_STATE.get().unwrap();
105    let storage = state.config.lock().unwrap().storage_path.clone();
106    let catalog = load_workspace_catalog();
107    let env = crate::context_binding::refresh_session_environment(
108        Path::new(&storage),
109        &catalog,
110        &session_id,
111    )
112    .map_err(|e| e.to_string())?;
113    serde_json::to_value(env).map_err(|e| e.to_string())
114}
115
116/// Updates the session environment.
117pub fn update_session_environment(
118    session_id: String,
119    ontology_ids: Vec<String>,
120    prior_session_ids: Vec<String>,
121    graph_mutation: bool,
122    axiom_start_year: u32,
123    axiom_end_year: u32,
124    spatial_context: String,
125) -> Result<serde_json::Value, String> {
126    let state = crate::state::APP_STATE.get().unwrap();
127    let storage = state.config.lock().unwrap().storage_path.clone();
128    let catalog = load_workspace_catalog();
129    let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
130        .map_err(|e| e.to_string())?;
131    let axiom_bounds = crate::context_binding::AxiomBounds {
132        start_year: axiom_start_year.min(u16::MAX as u32) as u16,
133        end_year: axiom_end_year.min(u16::MAX as u32) as u16,
134        spatial_context_hash: 0,
135        spatial_context_label: spatial_context.clone(),
136    }
137    .with_spatial_label(&spatial_context);
138
139    let config = crate::context_binding::ChatEnvironmentConfig {
140        session_id: session_id.clone(),
141        ontology_ids,
142        prior_session_ids,
143        session_kind: session.meta.session_kind,
144        participants: session.meta.participants.clone(),
145        graph_mutation,
146        axiom_bounds,
147    };
148    let env =
149        crate::context_binding::compile_chat_environment(Path::new(&storage), &catalog, &config)
150            .map_err(|e| e.to_string())?;
151    env.save_to_session_dir(Path::new(&storage))
152        .map_err(|e| e.to_string())?;
153    serde_json::to_value(env).map_err(|e| e.to_string())
154}
155
156/// Gets session-environment.
157pub fn get_session_environment(session_id: String) -> Result<serde_json::Value, String> {
158    let state = crate::state::APP_STATE.get().unwrap();
159    let storage = state.config.lock().unwrap().storage_path.clone();
160    let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
161        .map_err(|e| e.to_string())?;
162    serde_json::to_value(session.environment).map_err(|e| e.to_string())
163}
164
165/// Lists installed ontology IDs for chat.
166pub fn list_installed_ontology_ids_for_chat() -> Vec<String> {
167    let state = crate::state::APP_STATE.get().unwrap();
168    let storage = state.config.lock().unwrap().storage_path.clone();
169    crate::context_binding::list_installed_ontology_ids(Path::new(&storage))
170}
171
172/// Runs chat inference.
173pub fn run_chat_inference(session_id: String, prompt: String) -> Result<String, String> {
174    let result = run_chat_inference_dispatch(&session_id, &prompt);
175    if result.committed {
176        Ok(result.text)
177    } else {
178        Err(result
179            .block_reason
180            .unwrap_or_else(|| "Inference blocked".to_string()))
181    }
182}
183
184/// Runs detailed chat inference.
185pub fn run_chat_inference_detailed(
186    session_id: String,
187    prompt: String,
188) -> Result<serde_json::Value, String> {
189    let result = run_chat_inference_dispatch(&session_id, &prompt);
190    serde_json::to_value(result).map_err(|e| e.to_string())
191}
192
193/// Parse any `@mention` in the prompt and dispatch to the appropriate
194/// inference path. If no mention is found, uses the default path. If a
195/// mention resolves to a known roster agent, dispatches through
196/// [`run_chat_inference_for_agent`] with the stripped prompt. If the
197/// mention is unknown, returns an error result.
198fn run_chat_inference_dispatch(
199    session_id: &str,
200    prompt: &str,
201) -> crate::chat_inference::ChatInferenceResult {
202    use crate::chat_agents::{resolve_prompt_dispatch, PromptDispatch};
203
204    let storage = match crate::state::APP_STATE.get() {
205        Some(state) => state
206            .config
207            .lock()
208            .map(|c| c.storage_path.clone())
209            .unwrap_or_default(),
210        None => {
211            return crate::chat_inference::run_chat_inference_with_options(session_id, prompt, None)
212        }
213    };
214
215    match resolve_prompt_dispatch(std::path::Path::new(&storage), prompt) {
216        PromptDispatch::Default => {
217            crate::chat_inference::run_chat_inference_with_options(session_id, prompt, None)
218        }
219        PromptDispatch::Agent {
220            agent,
221            clean_prompt,
222        } => {
223            // T9+: If the agent has a DAG pipeline, execute it through the
224            // agent-turn handler. Otherwise, fall through to single-turn.
225            if !agent.dag_pipeline_json.is_empty() {
226                use crate::agent_turn_handler::{
227                    execute_agent_turn, AgentTurnConfig, AgentTurnOutcome,
228                };
229                let mut config = AgentTurnConfig {
230                    session_id: session_id.to_string(),
231                    storage_path: storage.clone(),
232                    agent_slug: agent.slug.clone(),
233                    dag_pipeline: None, // use agent's stored pipeline
234                };
235                match execute_agent_turn(&mut config) {
236                    AgentTurnOutcome::DagPipeline(result) => {
237                        let mut r = crate::chat_inference::ChatInferenceResult::default();
238                        r.text = result.summary();
239                        r
240                    }
241                    AgentTurnOutcome::SingleTurn => {
242                        // No DAG or non-local agent — fall through.
243                        crate::chat_inference::run_chat_inference_for_agent(
244                            session_id,
245                            &clean_prompt,
246                            Some(&agent.slug),
247                            None,
248                        )
249                    }
250                    AgentTurnOutcome::AgentUnavailable(reason) => {
251                        let mut r = crate::chat_inference::ChatInferenceResult::default();
252                        r.block_reason = Some(reason);
253                        r
254                    }
255                    AgentTurnOutcome::InvalidDag(reason) => {
256                        let mut r = crate::chat_inference::ChatInferenceResult::default();
257                        r.block_reason = Some(reason);
258                        r
259                    }
260                }
261            } else {
262                crate::chat_inference::run_chat_inference_for_agent(
263                    session_id,
264                    &clean_prompt,
265                    Some(&agent.slug),
266                    None,
267                )
268            }
269        }
270        PromptDispatch::UnknownAgent { slug, .. } => {
271            let mut result = crate::chat_inference::ChatInferenceResult::default();
272            result.block_reason = Some(format!("Unknown agent @{slug}"));
273            result
274        }
275    }
276}
277
278/// Cancels chat inference.
279pub fn cancel_chat_inference() {
280    crate::chat_inference::request_cancel_inference();
281}