1use crate::agents::ResidentAgentBroker;
4use crate::development::{DevelopmentError, DevelopmentResult, ToolCall};
5use serde::{Deserialize, Serialize};
6use serde_json::{Value, json};
7use std::collections::VecDeque;
8use std::fs;
9use std::io::{Read, Write};
10use std::path::{Path, PathBuf};
11use std::process::{Child, ChildStdin, Command, Stdio};
12use std::sync::Arc;
13use std::sync::mpsc::{self, Receiver, RecvTimeoutError};
14use std::thread;
15use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
16
17const MAX_FRAME_BYTES: usize = 16 * 1024 * 1024;
18const EVENT_CAPACITY: usize = 256;
19const RUNTIME_SOURCE: &str = include_str!("../assets/pi-runtime.mjs");
20pub const PINNED_PI_SDK_VERSION: &str = "0.84.3";
21const MINIMUM_NODE_VERSION: (u64, u64, u64) = (22, 19, 0);
22
23#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
24#[serde(rename_all = "camelCase")]
25pub enum PiReadinessState {
26 Ready,
27 Missing,
28 Incompatible,
29 Expired,
30 Unknown,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(rename_all = "camelCase")]
35pub struct PiReadinessComponent {
36 pub state: PiReadinessState,
37 pub version: Option<String>,
38 pub path: Option<PathBuf>,
39 pub detail: String,
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
43#[serde(rename_all = "camelCase")]
44pub struct PiReadiness {
45 pub ready: bool,
46 pub node: PiReadinessComponent,
47 pub sdk: PiReadinessComponent,
48 pub authentication: PiReadinessComponent,
49 pub provider: Option<String>,
50 pub model: Option<String>,
51 pub session: Option<String>,
52 pub agent_dir: PathBuf,
53 pub managed_root: PathBuf,
54 pub remediation: Vec<String>,
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(rename_all = "camelCase")]
59struct SelectedPiRuntime {
60 sdk_entry: PathBuf,
61 agent_dir: PathBuf,
62}
63
64#[derive(Debug, Clone)]
65pub enum PiSessionRequest {
66 Hello,
67 Prompt {
68 text: String,
69 context: Option<Value>,
70 },
71 Steer {
72 text: String,
73 context: Option<Value>,
74 },
75 FollowUp {
76 text: String,
77 context: Option<Value>,
78 },
79 Abort,
80 State,
81 Models,
82 SetModel {
83 provider: String,
84 model_id: String,
85 },
86 SetThinking {
87 level: String,
88 },
89 NewSession,
90 Compact {
91 instructions: Option<String>,
92 },
93 CloneSession,
94 Rewind {
95 entry_id: String,
96 },
97 Fork {
98 entry_id: String,
99 },
100 SwitchSession {
101 path: String,
102 },
103 ListSessions,
104 Entries {
105 since: Option<String>,
106 },
107 Tree,
108 Messages,
109 SessionStats,
110 SetSessionName {
111 name: String,
112 },
113}
114
115pub type PiToolExecutor =
116 Arc<dyn Fn(&ToolCall, bool, bool) -> DevelopmentResult<Value> + Send + Sync>;
117
118#[derive(Clone, Default)]
119pub struct PiRuntimeOptions {
120 pub unrestricted: bool,
121 pub session_dir: PathBuf,
122 pub name: Option<String>,
123 pub model: Option<String>,
124 pub thinking: Option<String>,
125 pub broker: Option<ResidentAgentBroker>,
126 pub local_tool_executor: Option<PiToolExecutor>,
127 pub additional_system_prompt: Option<String>,
128 pub resume: bool,
129}
130
131impl std::fmt::Debug for PiRuntimeOptions {
132 fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
133 formatter
134 .debug_struct("PiRuntimeOptions")
135 .field("unrestricted", &self.unrestricted)
136 .field("session_dir", &self.session_dir)
137 .field("name", &self.name)
138 .field("model", &self.model)
139 .field("thinking", &self.thinking)
140 .field("broker", &self.broker)
141 .field(
142 "local_tool_executor",
143 &self.local_tool_executor.as_ref().map(|_| "configured"),
144 )
145 .field("additional_system_prompt", &self.additional_system_prompt)
146 .field("resume", &self.resume)
147 .finish()
148 }
149}
150
151struct PendingPiToolApproval {
152 frame_id: String,
153 call: ToolCall,
154}
155
156pub struct GlassPiRuntime {
157 child: Child,
158 input: ChildStdin,
159 output: Receiver<Result<Value, String>>,
160 root: PathBuf,
161 broker: Option<ResidentAgentBroker>,
162 local_tool_executor: Option<PiToolExecutor>,
163 unrestricted: bool,
164 next_id: u64,
165 host_events: VecDeque<Value>,
166 pending_tool_approval: Option<PendingPiToolApproval>,
167 aborting_turn: bool,
168 unknown_tool_failures: u8,
169}
170
171impl std::fmt::Debug for GlassPiRuntime {
172 fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
173 formatter
174 .debug_struct("GlassPiRuntime")
175 .field("pid", &self.child.id())
176 .field("root", &self.root)
177 .finish_non_exhaustive()
178 }
179}
180
181impl GlassPiRuntime {
182 pub fn spawn(root: &Path, options: PiRuntimeOptions) -> DevelopmentResult<Self> {
183 validate_options(&options)?;
184 let root = fs::canonicalize(root)?;
185 fs::create_dir_all(&options.session_dir)?;
186 let session_dir = fs::canonicalize(&options.session_dir)?;
187 let runtime_path = materialize_runtime()?;
188 let sdk_entry = locate_sdk_entry()?;
189 let agent_dir = active_agent_dir(&sdk_entry)?;
190 fs::create_dir_all(&agent_dir)?;
191
192 let mut command = Command::new("node");
193 command
194 .arg(&runtime_path)
195 .env("GLASS_PI_SDK_ENTRY", sdk_entry)
196 .env("GLASS_PI_CWD", &root)
197 .env("GLASS_PI_SESSION_DIR", &session_dir)
198 .env("GLASS_PI_AGENT_DIR", &agent_dir)
199 .stdin(Stdio::piped())
200 .stdout(Stdio::piped())
201 .stderr(Stdio::inherit());
202 for (key, value) in [
203 ("GLASS_PI_SESSION_NAME", options.name.as_deref()),
204 ("GLASS_PI_MODEL", options.model.as_deref()),
205 ("GLASS_PI_THINKING", options.thinking.as_deref()),
206 (
207 "GLASS_PI_SYSTEM_PROMPT",
208 options.additional_system_prompt.as_deref(),
209 ),
210 ] {
211 if let Some(value) = value {
212 command.env(key, value);
213 }
214 }
215 if options.resume {
216 command.env("GLASS_PI_RESUME", "1");
217 }
218
219 let mut child = command.spawn().map_err(|error| {
220 DevelopmentError::Process(format!("failed to start Glass Pi SDK runtime: {error}"))
221 })?;
222 let input = child
223 .stdin
224 .take()
225 .ok_or_else(|| DevelopmentError::Process("Pi runtime stdin is unavailable".into()))?;
226 let output_stream = child
227 .stdout
228 .take()
229 .ok_or_else(|| DevelopmentError::Process("Pi runtime stdout is unavailable".into()))?;
230 let (sender, output) = mpsc::sync_channel(EVENT_CAPACITY);
231 thread::Builder::new()
232 .name("glass-pi-sdk-output".into())
233 .spawn(move || read_frames(output_stream, sender))?;
234
235 let mut runtime = Self {
236 child,
237 input,
238 output,
239 root,
240 local_tool_executor: options.local_tool_executor,
241 broker: options.broker,
242 unrestricted: options.unrestricted,
243 next_id: 1,
244 host_events: VecDeque::new(),
245 pending_tool_approval: None,
246 aborting_turn: false,
247 unknown_tool_failures: 0,
248 };
249 match runtime.recv_raw(Duration::from_secs(15))? {
250 Some(value) if value.get("type").and_then(Value::as_str) == Some("ready") => {
251 Ok(runtime)
252 }
253 Some(value) => Err(DevelopmentError::Process(format!(
254 "Pi SDK runtime emitted an unexpected startup frame: {value}"
255 ))),
256 None => Err(DevelopmentError::Process(
257 "Pi SDK runtime did not become ready within 15 seconds".into(),
258 )),
259 }
260 }
261
262 pub fn start_request(&mut self, request: PiSessionRequest) -> DevelopmentResult<String> {
263 let (operation, params) = request_parts(request);
264 let id = format!("glass-{}", self.next_id);
265 self.next_id = self.next_id.saturating_add(1);
266 self.send(&json!({"id": id, "operation": operation, "params": params}))?;
267 Ok(id)
268 }
269
270 pub fn recv_event_timeout(&mut self, timeout: Duration) -> DevelopmentResult<Option<Value>> {
271 if let Some(event) = self.host_events.pop_front() {
272 return Ok(Some(event));
273 }
274 let deadline = Instant::now() + timeout;
275 loop {
276 if let Some(event) = self.host_events.pop_front() {
277 return Ok(Some(event));
278 }
279 let Some(value) = self.recv_raw(deadline.saturating_duration_since(Instant::now()))?
280 else {
281 return Ok(None);
282 };
283 if value.get("type").and_then(Value::as_str) == Some("toolCall") {
284 if let Some(event) = self.handle_tool_call(&value)? {
285 return Ok(Some(event));
286 }
287 continue;
288 }
289 if value.get("type").and_then(Value::as_str) == Some("agent_settled") {
290 self.aborting_turn = false;
291 self.unknown_tool_failures = 0;
292 }
293 return Ok(Some(value));
294 }
295 }
296
297 pub fn resolve_tool_approval(
298 &mut self,
299 frame_id: &str,
300 approved: bool,
301 ) -> DevelopmentResult<()> {
302 let pending = self.pending_tool_approval.as_ref().ok_or_else(|| {
303 DevelopmentError::Conflict("no Pi tool call is awaiting approval".into())
304 })?;
305 if pending.frame_id != frame_id {
306 return Err(DevelopmentError::Conflict(format!(
307 "Pi approval frame {} is not the pending frame",
308 frame_id
309 )));
310 }
311 let pending = self
312 .pending_tool_approval
313 .take()
314 .ok_or_else(|| DevelopmentError::Conflict("Pi approval request disappeared".into()))?;
315 let result = if approved {
316 self.execute_tool_call(&pending.call, true, true)
317 } else {
318 Err(DevelopmentError::Conflict(
319 "Glass denied this Pi tool call".into(),
320 ))
321 };
322 self.send_tool_result(&pending.frame_id, &result)?;
323 self.host_events.push_back(json!({
324 "type": "glass_tool_approval_resolved",
325 "frameId": pending.frame_id,
326 "toolName": pending.call.name,
327 "approved": approved,
328 "ok": result.is_ok(),
329 }));
330 if approved {
331 self.host_events
332 .push_back(browser_evidence(&pending.call, &result));
333 }
334 Ok(())
335 }
336
337 fn recv_raw(&mut self, timeout: Duration) -> DevelopmentResult<Option<Value>> {
338 match self.output.recv_timeout(timeout) {
339 Ok(Ok(value)) => Ok(Some(value)),
340 Ok(Err(error)) => Err(DevelopmentError::Process(error)),
341 Err(RecvTimeoutError::Timeout) => Ok(None),
342 Err(RecvTimeoutError::Disconnected) => Err(DevelopmentError::Process(
343 "Pi SDK runtime event stream closed".into(),
344 )),
345 }
346 }
347
348 fn handle_tool_call(&mut self, value: &Value) -> DevelopmentResult<Option<Value>> {
349 let frame_id = value
350 .get("id")
351 .and_then(Value::as_str)
352 .ok_or_else(|| DevelopmentError::Serialization("Pi tool frame has no id".into()))?;
353 let call: ToolCall = normalize_tool_call(serde_json::from_value(
354 value.get("call").cloned().ok_or_else(|| {
355 DevelopmentError::Serialization("Pi tool frame has no call".into())
356 })?,
357 )?);
358 if !self.unrestricted && crate::tools::tool_requires_mutation(&call.name) {
359 if self.pending_tool_approval.is_some() {
360 return Err(DevelopmentError::Conflict(
361 "Pi emitted a second tool call while approval was pending".into(),
362 ));
363 }
364 self.pending_tool_approval = Some(PendingPiToolApproval {
365 frame_id: frame_id.into(),
366 call: call.clone(),
367 });
368 return Ok(Some(json!({
369 "type": "glass_tool_approval_request",
370 "frameId": frame_id,
371 "toolName": call.name,
372 "arguments": redact_tool_arguments(&call.arguments),
373 })));
374 }
375 let result = self.execute_tool_call(&call, self.unrestricted, self.unrestricted);
376 let unknown_tool = is_unknown_tool_error(&result);
377 let result = if unknown_tool {
378 result.map_err(|error| {
379 DevelopmentError::InvalidInput(format!(
380 "{error}; use a registered Glass capability such as `read`, `edit`, `bash`, `grep`, or `glass_tool`"
381 ))
382 })
383 } else {
384 result
385 };
386 self.send_tool_result(frame_id, &result)?;
387 self.host_events.push_back(browser_evidence(&call, &result));
388 if unknown_tool && !self.aborting_turn {
389 self.unknown_tool_failures = self.unknown_tool_failures.saturating_add(1);
390 if self.unknown_tool_failures >= 3 {
391 self.aborting_turn = true;
392 let abort_id = self.start_request(PiSessionRequest::Abort)?;
393 self.host_events.push_back(json!({
394 "type": "glass_tool_rejected",
395 "toolName": call.name,
396 "reason": "Repeated unknown Glass tool calls; the turn was aborted after three recoverable failures",
397 "recoverable": false,
398 "attempt": self.unknown_tool_failures,
399 "abortRequestId": abort_id,
400 }));
401 } else {
402 self.host_events.push_back(json!({
403 "type": "glass_tool_rejected",
404 "toolName": call.name,
405 "reason": "Glass returned an unknown tool error; the tool result was returned so Pi can retry with a registered tool",
406 "recoverable": true,
407 "attempt": self.unknown_tool_failures,
408 }));
409 }
410 }
411 Ok(None)
412 }
413
414 fn execute_tool_call(
415 &self,
416 call: &ToolCall,
417 allow_mutation: bool,
418 confirmed: bool,
419 ) -> DevelopmentResult<Value> {
420 if let Some(executor) = &self.local_tool_executor {
421 return executor(call, allow_mutation, confirmed);
422 }
423 match &self.broker {
424 Some(broker) => {
425 let runtime = tokio::runtime::Builder::new_current_thread()
426 .enable_io()
427 .build()
428 .map_err(DevelopmentError::Io)?;
429 runtime
430 .block_on(crate::daemon::forward_resident_tool_call_with_context(
431 broker,
432 call,
433 &self.root,
434 allow_mutation,
435 confirmed,
436 ))
437 .map_err(|error| DevelopmentError::Process(error.to_string()))
438 }
439 None => Err(DevelopmentError::Process(
440 "resident Pi has no authoritative Glass daemon broker".into(),
441 )),
442 }
443 }
444
445 fn send_tool_result(
446 &mut self,
447 frame_id: &str,
448 result: &DevelopmentResult<Value>,
449 ) -> DevelopmentResult<()> {
450 let response = match result {
451 Ok(result) => json!({
452 "operation": "toolResult", "id": frame_id, "ok": true, "result": result,
453 }),
454 Err(error) => json!({
455 "operation": "toolResult", "id": frame_id, "ok": false,
456 "error": error.to_string(),
457 }),
458 };
459 self.send(&response)
460 }
461
462 fn send(&mut self, value: &Value) -> DevelopmentResult<()> {
463 let encoded = serde_json::to_vec(value)?;
464 if encoded.is_empty() || encoded.len() > MAX_FRAME_BYTES {
465 return Err(DevelopmentError::InvalidInput(
466 "Pi SDK command exceeds the framed protocol limit".into(),
467 ));
468 }
469 self.input
470 .write_all(&(encoded.len() as u32).to_be_bytes())?;
471 self.input.write_all(&encoded)?;
472 self.input.flush()?;
473 Ok(())
474 }
475}
476
477fn normalize_tool_call(mut call: ToolCall) -> ToolCall {
478 let requested_name = call.name.clone();
479 let canonical = match requested_name.as_str() {
480 "read" | "glass.fs.read" => Some("glass.file.read"),
481 "ls" | "glass.fs.list" => Some("glass.file.list"),
482 "grep" | "glass.fs.grep" => Some("glass.file.grep"),
483 "find" | "glass.fs.find" => Some("glass.file.find"),
484 "write" | "glass.fs.write" => Some("glass.file.write"),
485 "edit" | "glass.fs.edit" => Some("glass.file.edit"),
486 "glass.fs.patch" => Some("glass.file.patch"),
487 "glass.fs.mkdir" => Some("glass.file.mkdir"),
488 "glass.fs.rename" => Some("glass.file.rename"),
489 "glass.fs.delete" | "glass.fs.remove" => Some("glass.file.delete"),
490 "bash" | "shell" | "terminal" | "glass.fs.shell" => Some("glass.command.run"),
491 _ => None,
492 };
493 let Some(canonical) = canonical else {
494 return call;
495 };
496 call.name = canonical.into();
497 if canonical == "glass.command.run" {
498 let mut arguments = match call.arguments {
499 Value::Object(arguments) => arguments,
500 _ => serde_json::Map::new(),
501 };
502 if !arguments.contains_key("name") {
503 let id = call
504 .id
505 .chars()
506 .map(|character| {
507 if character.is_ascii_alphanumeric() || matches!(character, '-' | '_') {
508 character
509 } else {
510 '-'
511 }
512 })
513 .take(48)
514 .collect::<String>();
515 arguments.insert("name".into(), Value::String(format!("pi-{id}")));
516 }
517 if let Some(timeout) = arguments.remove("timeout") {
518 arguments.insert("timeoutSeconds".into(), timeout);
519 }
520 call.arguments = Value::Object(arguments);
521 }
522 call
523}
524
525fn is_unknown_tool_error(result: &DevelopmentResult<Value>) -> bool {
526 matches!(
527 result,
528 Err(DevelopmentError::NotFound(message)) if message.starts_with("tool ")
529 )
530}
531fn browser_evidence(call: &ToolCall, result: &DevelopmentResult<Value>) -> Value {
532 let browser = call.name.starts_with("glass.browser.");
533 let mut evidence = serde_json::Map::new();
534 evidence.insert(
535 "type".into(),
536 Value::String(
537 if browser {
538 "glass_browser_evidence"
539 } else {
540 "glass_tool_evidence"
541 }
542 .into(),
543 ),
544 );
545 evidence.insert("toolName".into(), Value::String(call.name.clone()));
546 evidence.insert("ok".into(), Value::Bool(result.is_ok()));
547 if let Err(error) = result {
548 evidence.insert(
549 "error".into(),
550 Value::String(redact_text(&error.to_string())),
551 );
552 }
553 if let Ok(value) = result {
554 for key in [
555 "browserRevision",
556 "currentRevision",
557 "finalRevision",
558 "targetId",
559 "url",
560 "title",
561 "workflowState",
562 ] {
563 if let Some(value) = value
564 .get(key)
565 .filter(|value| value.is_string() || value.is_number() || value.is_boolean())
566 {
567 let value = if key == "url" {
568 value
569 .as_str()
570 .map(redact_url)
571 .map(Value::String)
572 .unwrap_or_else(|| value.clone())
573 } else {
574 value.clone()
575 };
576 evidence.insert(key.into(), value);
577 }
578 }
579 if let Some(revision) = value
580 .pointer("/accessibility/revision")
581 .and_then(Value::as_u64)
582 {
583 evidence.insert("browserRevision".into(), Value::from(revision));
584 }
585 if let Some(url) = value.pointer("/page/url").and_then(Value::as_str) {
586 evidence.insert("url".into(), Value::String(redact_url(url)));
587 }
588 if let Some(title) = value.pointer("/page/title").and_then(Value::as_str) {
589 evidence.insert("title".into(), Value::String(title.into()));
590 }
591 if let Some(count) = value
592 .pointer("/accessibility/interactive")
593 .and_then(Value::as_array)
594 .map(Vec::len)
595 {
596 evidence.insert("semanticEntityCount".into(), Value::from(count));
597 }
598 }
599 Value::Object(evidence)
600}
601fn redact_url(url: &str) -> String {
602 url.split(['?', '#'])
603 .next()
604 .unwrap_or(url)
605 .chars()
606 .take(2_048)
607 .collect()
608}
609
610fn redact_tool_arguments(value: &Value) -> Value {
611 match value {
612 Value::Object(object) => Value::Object(
613 object
614 .iter()
615 .map(|(key, value)| {
616 let redacted = key.to_ascii_lowercase();
617 let value = if [
618 "password",
619 "token",
620 "secret",
621 "cookie",
622 "authorization",
623 "api_key",
624 "apikey",
625 ]
626 .iter()
627 .any(|needle| redacted.contains(needle))
628 {
629 Value::String("[redacted]".into())
630 } else {
631 redact_tool_arguments(value)
632 };
633 (key.clone(), value)
634 })
635 .collect(),
636 ),
637 Value::Array(values) => Value::Array(values.iter().map(redact_tool_arguments).collect()),
638 _ => value.clone(),
639 }
640}
641
642fn redact_text(text: &str) -> String {
643 text.chars().take(2_048).collect()
644}
645
646impl Drop for GlassPiRuntime {
647 fn drop(&mut self) {
648 let _ = self.child.kill();
649 let _ = self.child.wait();
650 }
651}
652
653fn request_parts(request: PiSessionRequest) -> (&'static str, Value) {
654 match request {
655 PiSessionRequest::Hello => ("hello", Value::Null),
656 PiSessionRequest::Prompt { text, context } => {
657 ("prompt", json!({"text": text, "context": context}))
658 }
659 PiSessionRequest::Steer { text, context } => {
660 ("steer", json!({"text": text, "context": context}))
661 }
662 PiSessionRequest::FollowUp { text, context } => {
663 ("followUp", json!({"text": text, "context": context}))
664 }
665 PiSessionRequest::Abort => ("abort", Value::Null),
666 PiSessionRequest::State => ("state", Value::Null),
667 PiSessionRequest::Models => ("models", Value::Null),
668 PiSessionRequest::SetModel { provider, model_id } => (
669 "setModel",
670 json!({"provider": provider, "modelId": model_id}),
671 ),
672 PiSessionRequest::SetThinking { level } => ("setThinking", json!({"level": level})),
673 PiSessionRequest::NewSession => ("newSession", Value::Null),
674 PiSessionRequest::Compact { instructions } => {
675 ("compact", json!({"instructions": instructions}))
676 }
677 PiSessionRequest::CloneSession => ("cloneSession", Value::Null),
678 PiSessionRequest::Rewind { entry_id } => ("rewind", json!({"entryId": entry_id})),
679 PiSessionRequest::Fork { entry_id } => ("fork", json!({"entryId": entry_id})),
680 PiSessionRequest::SwitchSession { path } => ("switchSession", json!({"path": path})),
681 PiSessionRequest::ListSessions => ("listSessions", Value::Null),
682 PiSessionRequest::Entries { since } => ("entries", json!({"since": since})),
683 PiSessionRequest::Tree => ("tree", Value::Null),
684 PiSessionRequest::Messages => ("messages", Value::Null),
685 PiSessionRequest::SessionStats => ("stats", Value::Null),
686 PiSessionRequest::SetSessionName { name } => ("setName", json!({"name": name})),
687 }
688}
689
690fn read_frames(mut stream: impl Read, sender: mpsc::SyncSender<Result<Value, String>>) {
691 loop {
692 let mut header = [0_u8; 4];
693 if let Err(error) = stream.read_exact(&mut header) {
694 let _ = sender.send(Err(format!("Pi SDK runtime frame header failed: {error}")));
695 return;
696 }
697 let length = u32::from_be_bytes(header) as usize;
698 if length == 0 || length > MAX_FRAME_BYTES {
699 let _ = sender.send(Err("Pi SDK runtime emitted an invalid frame length".into()));
700 return;
701 }
702 let mut encoded = vec![0_u8; length];
703 if let Err(error) = stream.read_exact(&mut encoded) {
704 let _ = sender.send(Err(format!("Pi SDK runtime frame body failed: {error}")));
705 return;
706 }
707 let value = serde_json::from_slice(&encoded).map_err(|error| error.to_string());
708 if sender.send(value).is_err() {
709 return;
710 }
711 }
712}
713
714pub fn pi_readiness() -> DevelopmentResult<PiReadiness> {
715 let managed_root = managed_pi_root()?;
716 let node = node_readiness();
717 let sdk_candidate = locate_sdk_candidate();
718 let (sdk, agent_dir) = match sdk_candidate {
719 Ok((path, source)) => {
720 let version = sdk_version(&path);
721 let compatible = version
722 .as_deref()
723 .and_then(parse_version)
724 .is_some_and(|version| version >= (0, 84, 1));
725 let state = if compatible {
726 PiReadinessState::Ready
727 } else {
728 PiReadinessState::Incompatible
729 };
730 let agent_dir = active_agent_dir(&path)?;
731 (
732 PiReadinessComponent {
733 state,
734 version,
735 path: Some(path),
736 detail: if compatible {
737 format!("compatible {source} Pi SDK")
738 } else {
739 format!("{source} Pi SDK version is missing or older than 0.84.3")
740 },
741 },
742 agent_dir,
743 )
744 }
745 Err(error) => (
746 PiReadinessComponent {
747 state: PiReadinessState::Missing,
748 version: None,
749 path: None,
750 detail: error.to_string(),
751 },
752 managed_agent_dir()?,
753 ),
754 };
755 let (authentication, provider) = authentication_readiness(&agent_dir);
756 let ready = node.state == PiReadinessState::Ready
757 && sdk.state == PiReadinessState::Ready
758 && authentication.state == PiReadinessState::Ready;
759 let mut remediation = Vec::new();
760 if node.state != PiReadinessState::Ready {
761 remediation.push(format!(
762 "Install Node {}.{}.{} or newer, then run `glass agent setup`.",
763 MINIMUM_NODE_VERSION.0, MINIMUM_NODE_VERSION.1, MINIMUM_NODE_VERSION.2
764 ));
765 }
766 if sdk.state != PiReadinessState::Ready {
767 remediation.push("Run `glass agent setup` to install the pinned managed Pi SDK, or select an existing SDK with `--sdk-entry`.".into());
768 }
769 if authentication.state != PiReadinessState::Ready {
770 remediation.push("Run `glass agent setup --login`, use Pi `/login`, or configure a supported provider API-key environment variable.".into());
771 }
772 Ok(PiReadiness {
773 ready,
774 node,
775 sdk,
776 authentication,
777 provider,
778 model: None,
779 session: newest_session(&agent_dir),
780 agent_dir,
781 managed_root,
782 remediation,
783 })
784}
785
786pub fn setup_pi_runtime(
787 sdk_entry: Option<&Path>,
788 agent_dir: Option<&Path>,
789 update: bool,
790 login: bool,
791) -> DevelopmentResult<PiReadiness> {
792 let node = node_readiness();
793 if node.state != PiReadinessState::Ready {
794 return Err(DevelopmentError::Process(node.detail));
795 }
796 let managed_root = managed_pi_root()?;
797 fs::create_dir_all(&managed_root)?;
798 let selected = if let Some(entry) = sdk_entry {
799 let entry = canonical_file(entry.to_path_buf(), "selected Pi SDK")?;
800 let agent_dir = match agent_dir {
801 Some(path) => canonical_directory(path, "selected Pi agent directory")?,
802 None => default_pi_agent_dir()?,
803 };
804 SelectedPiRuntime {
805 sdk_entry: entry,
806 agent_dir,
807 }
808 } else {
809 let entry = managed_sdk_entry()?;
810 let installed = sdk_version(&entry).as_deref() == Some(PINNED_PI_SDK_VERSION);
811 if update || !installed {
812 install_managed_sdk(&managed_root)?;
813 }
814 SelectedPiRuntime {
815 sdk_entry: canonical_file(managed_sdk_entry()?, "managed Pi SDK")?,
816 agent_dir: managed_agent_dir()?,
817 }
818 };
819 fs::create_dir_all(&selected.agent_dir)?;
820 write_selected_runtime(&selected)?;
821 if login {
822 run_pi_login(&selected)?;
823 }
824 pi_readiness()
825}
826
827fn node_readiness() -> PiReadinessComponent {
828 let path = find_on_path(if cfg!(windows) { "node.exe" } else { "node" });
829 let Some(path) = path else {
830 return PiReadinessComponent {
831 state: PiReadinessState::Missing,
832 version: None,
833 path: None,
834 detail: "Node is not available on PATH".into(),
835 };
836 };
837 match Command::new(&path).arg("--version").output() {
838 Ok(output) if output.status.success() => {
839 let version = String::from_utf8_lossy(&output.stdout)
840 .trim()
841 .trim_start_matches('v')
842 .to_string();
843 let compatible =
844 parse_version(&version).is_some_and(|value| value >= MINIMUM_NODE_VERSION);
845 PiReadinessComponent {
846 state: if compatible {
847 PiReadinessState::Ready
848 } else {
849 PiReadinessState::Incompatible
850 },
851 version: Some(version.clone()),
852 path: Some(path),
853 detail: if compatible {
854 "compatible Node runtime".into()
855 } else {
856 format!("Node {version} is older than 22.19.0")
857 },
858 }
859 }
860 Ok(output) => PiReadinessComponent {
861 state: PiReadinessState::Unknown,
862 version: None,
863 path: Some(path),
864 detail: format!("Node version check exited {}", output.status),
865 },
866 Err(error) => PiReadinessComponent {
867 state: PiReadinessState::Unknown,
868 version: None,
869 path: Some(path),
870 detail: format!("Node version check failed: {error}"),
871 },
872 }
873}
874
875fn authentication_readiness(agent_dir: &Path) -> (PiReadinessComponent, Option<String>) {
876 const PROVIDER_KEYS: [(&str, &str); 10] = [
877 ("ANTHROPIC_API_KEY", "anthropic"),
878 ("OPENAI_API_KEY", "openai"),
879 ("GEMINI_API_KEY", "google"),
880 ("GOOGLE_API_KEY", "google"),
881 ("MISTRAL_API_KEY", "mistral"),
882 ("GROQ_API_KEY", "groq"),
883 ("XAI_API_KEY", "xai"),
884 ("OPENROUTER_API_KEY", "openrouter"),
885 ("ZAI_API_KEY", "zai"),
886 ("AWS_BEARER_TOKEN_BEDROCK", "amazon-bedrock"),
887 ];
888 if let Some((_, provider)) = PROVIDER_KEYS
889 .iter()
890 .find(|(key, _)| std::env::var_os(key).is_some())
891 {
892 return (
893 PiReadinessComponent {
894 state: PiReadinessState::Ready,
895 version: None,
896 path: None,
897 detail: format!("{provider} authentication is available from the environment"),
898 },
899 Some((*provider).into()),
900 );
901 }
902 let path = agent_dir.join("auth.json");
903 let encoded = match fs::read(&path) {
904 Ok(encoded) => encoded,
905 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
906 return (
907 PiReadinessComponent {
908 state: PiReadinessState::Missing,
909 version: None,
910 path: Some(path),
911 detail: "no Pi credentials are configured".into(),
912 },
913 None,
914 );
915 }
916 Err(error) => {
917 return (
918 PiReadinessComponent {
919 state: PiReadinessState::Unknown,
920 version: None,
921 path: Some(path),
922 detail: format!("Pi credential metadata is unreadable: {error}"),
923 },
924 None,
925 );
926 }
927 };
928 let value: Value = match serde_json::from_slice(&encoded) {
929 Ok(value) => value,
930 Err(error) => {
931 return (
932 PiReadinessComponent {
933 state: PiReadinessState::Unknown,
934 version: None,
935 path: Some(path),
936 detail: format!("Pi credential metadata is invalid JSON: {error}"),
937 },
938 None,
939 );
940 }
941 };
942 let providers = value
943 .as_object()
944 .map(|items| items.keys().take(8).cloned().collect::<Vec<_>>())
945 .unwrap_or_default();
946 if providers.is_empty() {
947 return (
948 PiReadinessComponent {
949 state: PiReadinessState::Missing,
950 version: None,
951 path: Some(path),
952 detail: "Pi credential file contains no providers".into(),
953 },
954 None,
955 );
956 }
957 let expired = value
958 .as_object()
959 .is_some_and(|items| items.values().all(credential_expired));
960 let state = if expired {
961 PiReadinessState::Expired
962 } else {
963 PiReadinessState::Ready
964 };
965 (
966 PiReadinessComponent {
967 state,
968 version: None,
969 path: Some(path),
970 detail: if expired {
971 "all stored Pi credentials appear expired".into()
972 } else {
973 format!("stored Pi credentials for {}", providers.join(", "))
974 },
975 },
976 providers.first().cloned(),
977 )
978}
979
980fn credential_expired(value: &Value) -> bool {
981 let now = SystemTime::now()
982 .duration_since(UNIX_EPOCH)
983 .unwrap_or_default()
984 .as_secs();
985 ["expires", "expiresAt", "expires_at", "expiration"]
986 .iter()
987 .find_map(|key| value.get(key))
988 .and_then(|value| value.as_u64().or_else(|| value.as_str()?.parse().ok()))
989 .is_some_and(|expires| {
990 let seconds = if expires > 10_000_000_000 {
991 expires / 1_000
992 } else {
993 expires
994 };
995 seconds <= now
996 })
997}
998
999fn newest_session(agent_dir: &Path) -> Option<String> {
1000 let sessions = agent_dir.join("sessions");
1001 let mut newest = None;
1002 for entry in fs::read_dir(sessions).ok()? {
1003 let entry = entry.ok()?;
1004 let modified = entry.metadata().ok()?.modified().ok()?;
1005 if newest
1006 .as_ref()
1007 .is_none_or(|(current, _)| modified > *current)
1008 {
1009 newest = Some((modified, entry.file_name().to_string_lossy().into_owned()));
1010 }
1011 }
1012 newest.map(|(_, name)| name)
1013}
1014
1015fn materialize_runtime() -> DevelopmentResult<PathBuf> {
1016 let base = dirs::cache_dir()
1017 .ok_or_else(|| DevelopmentError::Process("user cache directory is unavailable".into()))?
1018 .join("glass")
1019 .join("pi-sdk-v1");
1020 fs::create_dir_all(&base)?;
1021 let path = base.join("runtime.mjs");
1022 if fs::read_to_string(&path).ok().as_deref() != Some(RUNTIME_SOURCE) {
1023 let temporary = base.join(format!("runtime-{}.tmp", std::process::id()));
1024 fs::write(&temporary, RUNTIME_SOURCE)?;
1025 fs::rename(temporary, &path)?;
1026 }
1027 Ok(path)
1028}
1029
1030fn locate_sdk_entry() -> DevelopmentResult<PathBuf> {
1031 locate_sdk_candidate().map(|(path, _)| path)
1032}
1033
1034fn locate_sdk_candidate() -> DevelopmentResult<(PathBuf, &'static str)> {
1035 if let Some(path) = std::env::var_os("GLASS_PI_SDK_ENTRY") {
1036 return canonical_file(PathBuf::from(path), "GLASS_PI_SDK_ENTRY")
1037 .map(|path| (path, "environment-selected"));
1038 }
1039 if let Some(selected) = read_selected_runtime()
1040 && let Ok(path) = canonical_file(selected.sdk_entry, "selected Pi SDK")
1041 {
1042 return Ok((path, "Glass-selected"));
1043 }
1044 let managed = managed_sdk_entry()?;
1045 if managed.is_file() {
1046 return fs::canonicalize(managed)
1047 .map(|path| (path, "Glass-managed"))
1048 .map_err(DevelopmentError::Io);
1049 }
1050 let local = Path::new(env!("CARGO_MANIFEST_DIR")).join(
1051 "../../packages/pi-runtime/node_modules/@earendil-works/pi-coding-agent/dist/index.js",
1052 );
1053 if local.is_file() {
1054 return fs::canonicalize(local)
1055 .map(|path| (path, "repository"))
1056 .map_err(DevelopmentError::Io);
1057 }
1058 let pi = find_on_path("pi").ok_or_else(|| {
1059 DevelopmentError::NotFound(
1060 "Pi SDK is not ready; run `glass agent setup` or select an existing installation"
1061 .into(),
1062 )
1063 })?;
1064 let cli = fs::canonicalize(pi)?;
1065 canonical_file(cli.with_file_name("index.js"), "installed Pi SDK").map(|path| (path, "system"))
1066}
1067
1068fn active_agent_dir(sdk_entry: &Path) -> DevelopmentResult<PathBuf> {
1069 if let Some(path) = std::env::var_os("GLASS_PI_AGENT_DIR") {
1070 let path = PathBuf::from(path);
1071 fs::create_dir_all(&path)?;
1072 return fs::canonicalize(path).map_err(DevelopmentError::Io);
1073 }
1074 if let Some(selected) = read_selected_runtime()
1075 && canonical_file(selected.sdk_entry, "selected Pi SDK")
1076 .is_ok_and(|selected| selected == sdk_entry)
1077 {
1078 fs::create_dir_all(&selected.agent_dir)?;
1079 return fs::canonicalize(selected.agent_dir).map_err(DevelopmentError::Io);
1080 }
1081 managed_agent_dir()
1082}
1083
1084fn managed_pi_root() -> DevelopmentResult<PathBuf> {
1085 dirs::data_local_dir()
1086 .ok_or_else(|| DevelopmentError::Process("user local-data directory is unavailable".into()))
1087 .map(|root| root.join("glass").join("runtime").join("pi"))
1088}
1089
1090fn managed_agent_dir() -> DevelopmentResult<PathBuf> {
1091 Ok(managed_pi_root()?.join("agent"))
1092}
1093
1094fn default_pi_agent_dir() -> DevelopmentResult<PathBuf> {
1095 dirs::home_dir()
1096 .ok_or_else(|| DevelopmentError::Process("user home directory is unavailable".into()))
1097 .map(|home| home.join(".pi").join("agent"))
1098}
1099
1100fn managed_sdk_entry() -> DevelopmentResult<PathBuf> {
1101 Ok(managed_pi_root()?
1102 .join("node_modules")
1103 .join("@earendil-works")
1104 .join("pi-coding-agent")
1105 .join("dist")
1106 .join("index.js"))
1107}
1108
1109fn selected_runtime_path() -> DevelopmentResult<PathBuf> {
1110 Ok(managed_pi_root()?.join("selected-runtime.json"))
1111}
1112
1113fn read_selected_runtime() -> Option<SelectedPiRuntime> {
1114 let path = selected_runtime_path().ok()?;
1115 serde_json::from_slice(&fs::read(path).ok()?).ok()
1116}
1117
1118fn write_selected_runtime(selected: &SelectedPiRuntime) -> DevelopmentResult<()> {
1119 let path = selected_runtime_path()?;
1120 let parent = path.parent().ok_or_else(|| {
1121 DevelopmentError::Process("selected Pi runtime path has no parent".into())
1122 })?;
1123 fs::create_dir_all(parent)?;
1124 let temporary = parent.join(format!("selected-runtime-{}.tmp", std::process::id()));
1125 fs::write(&temporary, serde_json::to_vec_pretty(selected)?)?;
1126 fs::rename(temporary, path)?;
1127 Ok(())
1128}
1129
1130fn install_managed_sdk(root: &Path) -> DevelopmentResult<()> {
1131 let manifest = serde_json::json!({
1132 "name":"@glass-dev/managed-pi-runtime",
1133 "private":true,
1134 "dependencies":{"@earendil-works/pi-coding-agent":PINNED_PI_SDK_VERSION}
1135 });
1136 fs::write(
1137 root.join("package.json"),
1138 serde_json::to_vec_pretty(&manifest)?,
1139 )?;
1140 let status = Command::new(if cfg!(windows) { "npm.cmd" } else { "npm" })
1141 .args([
1142 "install",
1143 "--ignore-scripts",
1144 "--no-audit",
1145 "--no-fund",
1146 "--save-exact",
1147 &format!("@earendil-works/pi-coding-agent@{PINNED_PI_SDK_VERSION}"),
1148 ])
1149 .current_dir(root)
1150 .status()
1151 .map_err(|error| DevelopmentError::Process(format!("failed to start npm: {error}")))?;
1152 if !status.success() {
1153 return Err(DevelopmentError::Process(format!(
1154 "managed Pi SDK installation exited {status}"
1155 )));
1156 }
1157 Ok(())
1158}
1159
1160fn run_pi_login(selected: &SelectedPiRuntime) -> DevelopmentResult<()> {
1161 let managed_cli = managed_pi_root()?
1162 .join("node_modules")
1163 .join(".bin")
1164 .join(if cfg!(windows) { "pi.cmd" } else { "pi" });
1165 let cli = if managed_cli.is_file() {
1166 managed_cli
1167 } else {
1168 find_on_path(if cfg!(windows) { "pi.cmd" } else { "pi" })
1169 .ok_or_else(|| DevelopmentError::NotFound("Pi CLI for interactive `/login`".into()))?
1170 };
1171 eprintln!(
1172 "Glass is opening Pi with its selected credential directory. Run `/login`, then exit Pi to return to Glass."
1173 );
1174 let status = Command::new(cli)
1175 .env("PI_CODING_AGENT_DIR", &selected.agent_dir)
1176 .status()
1177 .map_err(|error| DevelopmentError::Process(format!("failed to open Pi login: {error}")))?;
1178 if !status.success() {
1179 return Err(DevelopmentError::Process(format!(
1180 "Pi login session exited {status}"
1181 )));
1182 }
1183 Ok(())
1184}
1185
1186fn sdk_version(entry: &Path) -> Option<String> {
1187 let package = entry.parent()?.parent()?.join("package.json");
1188 let value: Value = serde_json::from_slice(&fs::read(package).ok()?).ok()?;
1189 value.get("version")?.as_str().map(str::to_string)
1190}
1191
1192fn parse_version(value: &str) -> Option<(u64, u64, u64)> {
1193 let core = value
1194 .trim()
1195 .trim_start_matches('v')
1196 .split(['-', '+'])
1197 .next()?;
1198 let mut parts = core.split('.');
1199 Some((
1200 parts.next()?.parse().ok()?,
1201 parts.next()?.parse().ok()?,
1202 parts.next()?.parse().ok()?,
1203 ))
1204}
1205
1206fn canonical_directory(path: &Path, label: &str) -> DevelopmentResult<PathBuf> {
1207 let canonical = fs::canonicalize(path).map_err(|error| {
1208 DevelopmentError::Process(format!(
1209 "{label} is unavailable at {}: {error}",
1210 path.display()
1211 ))
1212 })?;
1213 if !canonical.is_dir() {
1214 return Err(DevelopmentError::Process(format!(
1215 "{label} is not a directory: {}",
1216 canonical.display()
1217 )));
1218 }
1219 Ok(canonical)
1220}
1221
1222fn canonical_file(path: PathBuf, label: &str) -> DevelopmentResult<PathBuf> {
1223 let canonical = fs::canonicalize(&path).map_err(|error| {
1224 DevelopmentError::Process(format!(
1225 "{label} is unavailable at {}: {error}",
1226 path.display()
1227 ))
1228 })?;
1229 if !canonical.is_file() {
1230 return Err(DevelopmentError::Process(format!(
1231 "{label} is not a file: {}",
1232 canonical.display()
1233 )));
1234 }
1235 Ok(canonical)
1236}
1237
1238fn find_on_path(name: &str) -> Option<PathBuf> {
1239 std::env::var_os("PATH").and_then(|path| {
1240 std::env::split_paths(&path)
1241 .map(|directory| directory.join(name))
1242 .find(|candidate| candidate.is_file())
1243 })
1244}
1245
1246fn validate_options(options: &PiRuntimeOptions) -> DevelopmentResult<()> {
1247 if options.session_dir.as_os_str().is_empty() {
1248 return Err(DevelopmentError::InvalidInput(
1249 "Pi session directory is required".into(),
1250 ));
1251 }
1252 for (label, value, limit) in [
1253 ("Pi session name", options.name.as_deref(), 1024),
1254 ("Pi model", options.model.as_deref(), 1024),
1255 ("Pi thinking level", options.thinking.as_deref(), 128),
1256 (
1257 "Pi system prompt",
1258 options.additional_system_prompt.as_deref(),
1259 128 * 1024,
1260 ),
1261 ] {
1262 if value.is_some_and(|value| value.len() > limit || value.contains('\0')) {
1263 return Err(DevelopmentError::InvalidInput(format!("invalid {label}")));
1264 }
1265 }
1266 Ok(())
1267}
1268
1269#[cfg(test)]
1270mod tests {
1271 use super::*;
1272 use std::sync::Arc;
1273
1274 fn response(runtime: &mut GlassPiRuntime, request: PiSessionRequest) -> Value {
1275 let id = runtime.start_request(request).unwrap();
1276 loop {
1277 let value = runtime
1278 .recv_event_timeout(Duration::from_secs(10))
1279 .unwrap()
1280 .expect("native SDK response");
1281 if value.get("type").and_then(Value::as_str) == Some("response")
1282 && value.get("id").and_then(Value::as_str) == Some(&id)
1283 {
1284 return value;
1285 }
1286 }
1287 }
1288 fn unknown_tool_rejection_count(runtime: &GlassPiRuntime) -> usize {
1289 runtime
1290 .host_events
1291 .iter()
1292 .filter(|event| {
1293 event.get("type").and_then(Value::as_str) == Some("glass_tool_rejected")
1294 })
1295 .count()
1296 }
1297
1298 #[test]
1299 fn request_mapping_uses_native_sdk_operations() {
1300 assert_eq!(request_parts(PiSessionRequest::Hello).0, "hello");
1301 assert_eq!(
1302 request_parts(PiSessionRequest::FollowUp {
1303 text: "next".into(),
1304 context: None,
1305 })
1306 .0,
1307 "followUp"
1308 );
1309 let (_, params) = request_parts(PiSessionRequest::Prompt {
1310 text: "inspect".into(),
1311 context: Some(json!({
1312 "schemaVersion": "glass.agent-context.v1",
1313 "browser": {"browserRevision": 7}
1314 })),
1315 });
1316 assert_eq!(params["context"]["browser"]["browserRevision"], 7);
1317 assert_eq!(request_parts(PiSessionRequest::SessionStats).0, "stats");
1318 }
1319
1320 #[test]
1321 fn runtime_asset_never_invokes_pi_rpc_cli() {
1322 assert!(!RUNTIME_SOURCE.contains("--mode"));
1323 assert!(!RUNTIME_SOURCE.contains("--mode rpc"));
1324 assert!(RUNTIME_SOURCE.contains("createAgentSession"));
1325 assert!(RUNTIME_SOURCE.contains("SessionManager"));
1326 }
1327
1328 #[test]
1329 fn runtime_asset_registers_governed_custom_tools_without_builtins() {
1330 assert!(RUNTIME_SOURCE.contains("noTools: \"builtin\""));
1331 assert!(RUNTIME_SOURCE.contains("tools: [\"glass_tool\", \"delegate\", \"read\""));
1332 assert!(RUNTIME_SOURCE.contains("\"glass.agent.delegate\""));
1333 assert!(RUNTIME_SOURCE.contains("customTools: [glassTool, ...nativeTools]"));
1334 }
1335 #[test]
1336 fn unknown_tool_call_recovers_then_aborts_once() {
1337 if locate_sdk_entry().is_err() {
1338 return;
1339 }
1340 let root =
1341 std::env::temp_dir().join(format!("glass-pi-unknown-tool-test-{}", std::process::id()));
1342 let sessions = root.join("sessions");
1343 fs::create_dir_all(&root).unwrap();
1344 let executor: PiToolExecutor =
1345 Arc::new(|_, _, _| Err(DevelopmentError::NotFound("tool glass.fs.list".into())));
1346 let mut runtime = GlassPiRuntime::spawn(
1347 &root,
1348 PiRuntimeOptions {
1349 session_dir: sessions,
1350 local_tool_executor: Some(executor),
1351 ..PiRuntimeOptions::default()
1352 },
1353 )
1354 .unwrap();
1355 let call = serde_json::json!({
1356 "type": "toolCall",
1357 "id": "unknown-tool-frame",
1358 "call": {"id": "unknown-tool-call", "name": "glass.fs.list", "arguments": {}}
1359 });
1360
1361 assert!(runtime.handle_tool_call(&call).unwrap().is_none());
1362 assert!(!runtime.aborting_turn);
1363 assert_eq!(unknown_tool_rejection_count(&runtime), 1);
1364 assert_eq!(
1365 runtime
1366 .host_events
1367 .back()
1368 .and_then(|event| event.get("attempt")),
1369 Some(&json!(1))
1370 );
1371
1372 assert!(runtime.handle_tool_call(&call).unwrap().is_none());
1373 assert!(!runtime.aborting_turn);
1374 assert_eq!(unknown_tool_rejection_count(&runtime), 2);
1375
1376 assert!(runtime.handle_tool_call(&call).unwrap().is_none());
1377 assert!(runtime.aborting_turn);
1378 assert_eq!(unknown_tool_rejection_count(&runtime), 3);
1379 assert_eq!(
1380 runtime
1381 .host_events
1382 .back()
1383 .and_then(|event| event.get("recoverable")),
1384 Some(&json!(false))
1385 );
1386
1387 assert!(runtime.handle_tool_call(&call).unwrap().is_none());
1388 assert_eq!(unknown_tool_rejection_count(&runtime), 3);
1389 drop(runtime);
1390 fs::remove_dir_all(&root).unwrap();
1391 }
1392
1393 #[test]
1394 fn readiness_version_and_expiry_checks_are_deterministic() {
1395 assert_eq!(parse_version("v22.19.0"), Some((22, 19, 0)));
1396 assert_eq!(parse_version("0.84.3-beta.1"), Some((0, 84, 3)));
1397 assert_eq!(parse_version("invalid"), None);
1398 assert!(credential_expired(&serde_json::json!({"expires":1})));
1399 assert!(!credential_expired(&serde_json::json!({
1400 "expires":9_999_999_999_u64
1401 })));
1402 assert!(!credential_expired(&serde_json::json!({"type":"api_key"})));
1403 }
1404
1405 #[test]
1406 fn browser_evidence_redacts_url_query_and_fragment() {
1407 assert_eq!(
1408 redact_url("https://example.test/orders/7?token=secret#receipt"),
1409 "https://example.test/orders/7"
1410 );
1411 }
1412
1413 #[test]
1414 fn native_sdk_starts_and_reports_capabilities_when_installed() {
1415 if locate_sdk_entry().is_err() {
1416 return;
1417 }
1418 let root =
1419 std::env::temp_dir().join(format!("glass-pi-native-sdk-test-{}", std::process::id()));
1420 let sessions = root.join("sessions");
1421 fs::create_dir_all(&root).unwrap();
1422 let mut runtime = GlassPiRuntime::spawn(
1423 &root,
1424 PiRuntimeOptions {
1425 session_dir: sessions,
1426 name: Some("native SDK contract test".into()),
1427 ..PiRuntimeOptions::default()
1428 },
1429 )
1430 .unwrap();
1431 let hello = response(&mut runtime, PiSessionRequest::Hello);
1432 assert_eq!(hello.get("ok").and_then(Value::as_bool), Some(true));
1433 assert_eq!(
1434 hello.pointer("/result/protocol").and_then(Value::as_str),
1435 Some("glass-pi-sdk-v1")
1436 );
1437 let named = response(
1438 &mut runtime,
1439 PiSessionRequest::SetSessionName {
1440 name: "renamed SDK session".into(),
1441 },
1442 );
1443 assert_eq!(named.get("ok").and_then(Value::as_bool), Some(true));
1444 assert_eq!(
1445 response(&mut runtime, PiSessionRequest::SessionStats)
1446 .get("ok")
1447 .and_then(Value::as_bool),
1448 Some(true)
1449 );
1450 assert!(
1451 response(&mut runtime, PiSessionRequest::Tree)
1452 .pointer("/result")
1453 .is_some()
1454 );
1455 assert!(
1456 response(&mut runtime, PiSessionRequest::Messages)
1457 .pointer("/result")
1458 .is_some()
1459 );
1460 let cloned = response(&mut runtime, PiSessionRequest::CloneSession);
1461 assert_eq!(
1462 cloned.get("ok").and_then(Value::as_bool),
1463 Some(false),
1464 "{cloned}"
1465 );
1466 assert!(
1467 cloned
1468 .get("error")
1469 .and_then(Value::as_str)
1470 .is_some_and(|error| error.contains("empty or invalid"))
1471 );
1472 assert_eq!(
1473 response(&mut runtime, PiSessionRequest::NewSession)
1474 .get("ok")
1475 .and_then(Value::as_bool),
1476 Some(true)
1477 );
1478 assert!(
1479 response(&mut runtime, PiSessionRequest::ListSessions)
1480 .pointer("/result")
1481 .and_then(Value::as_array)
1482 .is_some()
1483 );
1484 let rejected = response(
1485 &mut runtime,
1486 PiSessionRequest::SwitchSession {
1487 path: root.join("outside.jsonl").display().to_string(),
1488 },
1489 );
1490 assert_eq!(rejected.get("ok").and_then(Value::as_bool), Some(false));
1491 drop(runtime);
1492 fs::remove_dir_all(&root).unwrap();
1493 }
1494}