1#![allow(non_snake_case)]
4
5use super::*;
6
7use std::path::Path;
8
9pub 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
16pub 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
25pub 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
34pub 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
43pub 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
68pub 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
77pub 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
84pub 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
92pub fn get_last_chat_session_id() -> Option<String> {
94 crate::chat_session::get_last_session_id()
95}
96
97pub 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
102pub 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
116pub 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
156pub 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
165pub 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
172pub 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
184pub 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
193fn 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 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, };
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 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
278pub fn cancel_chat_inference() {
280 crate::chat_inference::request_cancel_inference();
281}