Skip to main content

glass_dev/
pi_runtime.rs

1//! Glass-owned host for Pi's native `AgentSession` SDK runtime.
2
3use 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}