1use super::{Actor, DevelopmentError, DevelopmentEventKind, DevelopmentResult, ProjectWorkspace};
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4use sha2::{Digest, Sha256};
5use std::{
6 collections::{BTreeSet, VecDeque},
7 io::{BufRead, BufReader, Write},
8 path::{Path, PathBuf},
9 process::{Child, ChildStdin, Command, Stdio},
10 sync::mpsc::{self, Receiver, RecvTimeoutError},
11 thread,
12 time::Duration,
13};
14
15const MAX_PI_EVENT_BYTES: usize = 512 * 1024;
16const MAX_PI_BUFFERED_EVENTS: usize = 64;
17const PI_EVENT_CHANNEL_CAPACITY: usize = 32;
18
19#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
20#[serde(rename_all = "camelCase")]
21pub struct ToolDescriptor {
22 pub name: String,
23 pub description: String,
24 pub input_schema: Value,
25 pub mutating: bool,
26 pub available: bool,
27 #[serde(default, skip_serializing_if = "Option::is_none")]
28 pub unavailable_reason: Option<String>,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
32#[serde(rename_all = "camelCase")]
33pub struct AgentContextPacket {
34 pub schema_version: String,
35 pub references: Vec<String>,
36 pub project: Value,
37 pub diagnostics: Value,
38 pub processes: Value,
39 pub recent_events: Value,
40 pub resolved: Value,
41 pub browser: Option<BrowserAgentContext>,
42 pub authority: AgentAuthorityContext,
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
46#[serde(rename_all = "camelCase")]
47pub struct BrowserAgentContext {
48 pub connected: bool,
49 pub target_id: Option<String>,
50 pub origin: Option<String>,
51 pub title: String,
52 pub browser_revision: u64,
53 pub semantic_summary: String,
54 pub workflow_state: String,
55 pub memory_scope: String,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
59#[serde(rename_all = "camelCase")]
60pub struct AgentAuthorityContext {
61 pub project_revision: u64,
62 pub browser_revision: Option<u64>,
63 pub mutation_lease_required: bool,
64 pub stale_context_rejected: bool,
65}
66
67pub fn resolve_context(
68 workspace: &mut ProjectWorkspace,
69 prompt: &str,
70) -> DevelopmentResult<AgentContextPacket> {
71 resolve_context_with_browser(workspace, prompt, None)
72}
73
74pub fn resolve_context_with_browser(
75 workspace: &mut ProjectWorkspace,
76 prompt: &str,
77 browser: Option<&BrowserAgentContext>,
78) -> DevelopmentResult<AgentContextPacket> {
79 if prompt.len() > 8 * 1024 {
80 return Err(DevelopmentError::InvalidInput(
81 "prompt exceeds the 8192 byte context limit".into(),
82 ));
83 }
84 let mut references = prompt
85 .split_whitespace()
86 .filter(|token| token.starts_with('@'))
87 .map(|token| {
88 token
89 .trim_matches(|character: char| {
90 matches!(character, ',' | '.' | '?' | '!' | ')' | ']')
91 })
92 .to_string()
93 })
94 .collect::<Vec<_>>();
95 references.sort();
96 references.dedup();
97 if references.len() > 32 {
98 return Err(DevelopmentError::InvalidInput(
99 "agent context cannot contain more than 32 references".into(),
100 ));
101 }
102 let mut resolved = serde_json::Map::new();
103 for reference in &references {
104 let value = match reference.as_str() {
105 "@workspace" => serde_json::to_value(workspace.detection())?,
106 "@diagnostic" => serde_json::to_value(workspace.diagnostics())?,
107 "@run:last" => workspace
108 .timeline()
109 .events()
110 .next_back()
111 .map(serde_json::to_value)
112 .transpose()?
113 .unwrap_or(Value::Null),
114 "@page" | "@browser" => browser.map(serde_json::to_value).transpose()?.unwrap_or_else(|| serde_json::json!({
115 "status": "requires-attached-browser-workspace", "defaultObservation": "structured"
116 })),
117 value if value.starts_with("@entity:") => {
118 serde_json::to_value(workspace.graph().links_for(&value[8..]))?
119 }
120 value if value.starts_with("@file:") => {
121 let path = &value[6..];
122 let content = workspace.read_file(path)?;
123 serde_json::json!({"path": path, "bytes": content.len(), "sha256": prompt_evidence(&content)["sha256"]})
124 }
125 value if value.starts_with("@revision:") => {
126 let index = value[10..].parse::<usize>().map_err(|_| {
127 DevelopmentError::InvalidInput(format!("invalid revision reference: {value}"))
128 })?;
129 serde_json::to_value(workspace.replay(index, 1)?)?
130 }
131 "@workflow" => browser.map(|value| serde_json::json!({"state":value.workflow_state,"browserRevision":value.browser_revision})).unwrap_or_else(|| serde_json::json!({"status":"not-attached"})),
132 "@memory" => browser.map(|value| serde_json::json!({"scope":value.memory_scope,"authoritative":false})).unwrap_or_else(|| serde_json::json!({"status":"not-attached"})),
133 "@selection" | "@file" | "@symbol" => serde_json::json!({"status": "not-selected"}),
134 value => {
135 return Err(DevelopmentError::InvalidInput(format!(
136 "unsupported agent context reference: {value}"
137 )));
138 }
139 };
140 resolved.insert(reference.clone(), value);
141 }
142 let processes = workspace.processes().list_checked()?;
143 let events = workspace
144 .timeline()
145 .events()
146 .rev()
147 .take(32)
148 .collect::<Vec<_>>();
149 let project_revision = workspace.revision();
150 Ok(AgentContextPacket {
151 schema_version: "glass.agent-context.v1".into(),
152 references,
153 project: serde_json::to_value(workspace.detection())?,
154 diagnostics: serde_json::to_value(workspace.diagnostics())?,
155 processes: serde_json::to_value(processes)?,
156 recent_events: serde_json::to_value(events)?,
157 resolved: Value::Object(resolved),
158 browser: browser.cloned(),
159 authority: AgentAuthorityContext {
160 project_revision,
161 browser_revision: browser.map(|value| value.browser_revision),
162 mutation_lease_required: true,
163 stale_context_rejected: true,
164 },
165 })
166}
167
168#[derive(Debug, Clone, Default)]
169pub struct ToolRegistry;
170
171const MAX_TOOL_ARGUMENT_BYTES: usize = 256 * 1024;
172const MAX_TOOL_RESULT_BYTES: usize = 64 * 1024;
173const MAX_TOOL_CALL_ID_BYTES: usize = 128;
174const MAX_TOOL_NAME_BYTES: usize = 128;
175const MAX_GREP_FILES: usize = 512;
176const MAX_GREP_BYTES: u64 = 32 * 1024 * 1024;
177
178#[derive(Debug, Clone)]
179pub struct ToolAuthorization {
180 pub actor: Actor,
181 pub allow_mutation: bool,
182 pub confirmed: bool,
183}
184
185impl ToolAuthorization {
186 pub fn read_only(actor: Actor) -> Self {
187 Self {
188 actor,
189 allow_mutation: false,
190 confirmed: false,
191 }
192 }
193}
194
195#[derive(Debug, Clone)]
196pub struct AgentToolGateway {
197 registry: ToolRegistry,
198 descriptors: Vec<ToolDescriptor>,
199 browser_context: Option<BrowserAgentContext>,
200}
201
202impl Default for AgentToolGateway {
203 fn default() -> Self {
204 let registry = ToolRegistry;
205 let descriptors = registry.descriptors();
206 Self {
207 registry,
208 descriptors,
209 browser_context: None,
210 }
211 }
212}
213
214impl AgentToolGateway {
215 pub fn subprocess_broker() -> Self {
216 let mut gateway = Self::default();
217 for descriptor in &mut gateway.descriptors {
218 if matches!(
219 descriptor.name.as_str(),
220 "glass.process.start"
221 | "glass.process.stop"
222 | "glass.process.logs"
223 | "glass.process.list"
224 ) {
225 descriptor.available = false;
226 descriptor.unavailable_reason =
227 Some("Requires a resident Glass Dev session that owns the managed PTY".into());
228 }
229 }
230 gateway
231 }
232
233 pub fn set_browser_context(&mut self, context: Option<BrowserAgentContext>) {
234 self.browser_context = context;
235 for descriptor in &mut self.descriptors {
236 let available = match descriptor.name.as_str() {
237 "glass.browser.observe" | "glass.memory.retrieve" => self
238 .browser_context
239 .as_ref()
240 .is_some_and(|value| value.connected),
241 "glass.workflow.pause" | "glass.workflow.resume" => self
242 .browser_context
243 .as_ref()
244 .is_some_and(|value| value.connected && value.workflow_state == "active"),
245 _ => continue,
246 };
247 descriptor.available = available;
248 descriptor.unavailable_reason = (!available).then(|| match descriptor.name.as_str() {
249 "glass.memory.retrieve" => {
250 "Requires an attached profile-scoped semantic memory store".into()
251 }
252 name if name.starts_with("glass.workflow") => {
253 "Requires an active browser workflow run".into()
254 }
255 _ => "Requires an attached Browser Workspace".into(),
256 });
257 }
258 }
259
260 pub fn descriptors(&self) -> Vec<ToolDescriptor> {
261 self.descriptors.clone()
262 }
263
264 pub fn execute(
265 &self,
266 workspace: &mut ProjectWorkspace,
267 call: &ToolCall,
268 authorization: &ToolAuthorization,
269 ) -> DevelopmentResult<Value> {
270 validate_tool_call_envelope(call)?;
271 let descriptor = self
272 .descriptors
273 .iter()
274 .find(|descriptor| descriptor.name == call.name)
275 .ok_or_else(|| DevelopmentError::NotFound(format!("tool {}", call.name)))?;
276 if !descriptor.available {
277 return Err(DevelopmentError::InvalidInput(
278 descriptor
279 .unavailable_reason
280 .clone()
281 .unwrap_or_else(|| format!("tool {} is unavailable", descriptor.name)),
282 ));
283 }
284 let argument_evidence = validate_tool_arguments(descriptor, &call.arguments)?;
285 if descriptor.mutating && (!authorization.allow_mutation || !authorization.confirmed) {
286 return Err(DevelopmentError::Conflict(format!(
287 "tool {} requires explicit mutation authority and confirmation",
288 descriptor.name
289 )));
290 }
291 workspace.record_as(
292 authorization.actor.clone(),
293 DevelopmentEventKind::AgentToolCalled,
294 tool_call_evidence(call, descriptor.mutating, &argument_evidence),
295 )?;
296 let result = if call.name == "glass.capabilities.inspect" {
297 Ok(serde_json::to_value(&self.descriptors)?)
298 } else {
299 self.execute_attached(call).unwrap_or_else(|| {
300 self.registry
301 .execute_unchecked(workspace, call, authorization.actor.clone())
302 })
303 };
304 let (ok, bytes) = match &result {
305 Ok(value) => {
306 let mut counter = BoundedJsonWriter::new(MAX_TOOL_RESULT_BYTES);
307 let serialized = serde_json::to_writer(&mut counter, value);
308 if counter.exceeded {
309 workspace.record_as(
310 authorization.actor.clone(),
311 DevelopmentEventKind::AgentToolResult,
312 serde_json::json!({"id": call.id, "name": call.name, "ok": false, "reason": "result-limit", "bytes": counter.bytes}),
313 )?;
314 return Err(DevelopmentError::InvalidInput(format!(
315 "tool result exceeds the {MAX_TOOL_RESULT_BYTES} byte limit"
316 )));
317 }
318 serialized?;
319 (true, counter.bytes)
320 }
321 Err(_) => (false, 0),
322 };
323 workspace.record_as(
324 authorization.actor.clone(),
325 DevelopmentEventKind::AgentToolResult,
326 serde_json::json!({"id": call.id, "name": call.name, "ok": ok, "bytes": bytes}),
327 )?;
328 result
329 }
330
331 fn execute_attached(&self, call: &ToolCall) -> Option<DevelopmentResult<Value>> {
332 let context = self.browser_context.as_ref()?;
333 match call.name.as_str() {
334 "glass.browser.observe" => Some(Ok(serde_json::json!({
335 "structured": true,
336 "targetId": context.target_id,
337 "origin": context.origin,
338 "title": context.title,
339 "browserRevision": context.browser_revision,
340 "semanticSummary": context.semantic_summary,
341 "freshness": "current-context-packet"
342 }))),
343 "glass.memory.retrieve" => Some(Ok(serde_json::json!({
344 "scope": context.memory_scope,
345 "authoritative": false,
346 "requiresFreshSemanticEvidence": true
347 }))),
348 "glass.workflow.pause" | "glass.workflow.resume" => Some(Ok(serde_json::json!({
349 "workflowState": context.workflow_state,
350 "browserRevision": context.browser_revision,
351 "requiresMutationLease": true
352 }))),
353 _ => None,
354 }
355 }
356}
357
358impl ToolRegistry {
359 pub fn descriptors(&self) -> Vec<ToolDescriptor> {
360 let schema = |properties: Value, required: &[&str]| serde_json::json!({"type":"object", "properties": properties, "required": required, "additionalProperties": false});
361 vec![
362 descriptor(
363 "glass.file.read",
364 "Read one bounded project file",
365 schema(
366 serde_json::json!({"path":{"type":"string"},"offset":{"type":"integer"},"limit":{"type":"integer"}}),
367 &["path"],
368 ),
369 false,
370 ),
371 descriptor(
372 "glass.file.list",
373 "List bounded project files",
374 schema(
375 serde_json::json!({"path":{"type":"string"},"limit":{"type":"integer"}}),
376 &[],
377 ),
378 false,
379 ),
380 descriptor(
381 "glass.file.search",
382 "Search files, entities, processes, events, and commands",
383 schema(serde_json::json!({"query":{"type":"string"}}), &["query"]),
384 false,
385 ),
386 descriptor(
387 "glass.file.grep",
388 "Search bounded UTF-8 project files for a literal text pattern",
389 schema(
390 serde_json::json!({"pattern":{"type":"string"},"path":{"type":"string"},"glob":{"type":"string"},"ignoreCase":{"type":"boolean"},"context":{"type":"integer"},"limit":{"type":"integer"}}),
391 &["pattern"],
392 ),
393 false,
394 ),
395 descriptor(
396 "glass.file.find",
397 "Find bounded project paths with shell-style star and question-mark matching",
398 schema(
399 serde_json::json!({"pattern":{"type":"string"},"path":{"type":"string"},"limit":{"type":"integer"}}),
400 &["pattern"],
401 ),
402 false,
403 ),
404 descriptor(
405 "glass.file.patch",
406 "Replace bounded text through an attributed editor buffer",
407 schema(
408 serde_json::json!({"path":{"type":"string"},"search":{"type":"string"},"replace":{"type":"string"}}),
409 &["path", "search", "replace"],
410 ),
411 true,
412 ),
413 descriptor(
414 "glass.file.edit",
415 "Apply one atomic set of exact non-overlapping replacements",
416 schema(
417 serde_json::json!({"path":{"type":"string"},"edits":{"type":"array"}}),
418 &["path", "edits"],
419 ),
420 true,
421 ),
422 descriptor(
423 "glass.file.write",
424 "Create or replace one bounded project file",
425 schema(
426 serde_json::json!({"path":{"type":"string"},"content":{"type":"string"}}),
427 &["path", "content"],
428 ),
429 true,
430 ),
431 descriptor(
432 "glass.file.mkdir",
433 "Create one workspace-confined directory tree",
434 schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
435 true,
436 ),
437 descriptor(
438 "glass.file.rename",
439 "Rename one workspace-confined path",
440 schema(
441 serde_json::json!({"from":{"type":"string"},"to":{"type":"string"}}),
442 &["from", "to"],
443 ),
444 true,
445 ),
446 descriptor(
447 "glass.file.delete",
448 "Delete one file or empty directory",
449 schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
450 true,
451 ),
452 descriptor(
453 "glass.process.start",
454 "Start a named PTY process",
455 schema(
456 serde_json::json!({"name":{"type":"string"},"command":{"type":"string"}}),
457 &["name", "command"],
458 ),
459 true,
460 ),
461 descriptor(
462 "glass.process.stop",
463 "Stop a named managed process",
464 schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
465 true,
466 ),
467 descriptor(
468 "glass.process.logs",
469 "Read a bounded managed-process output tail",
470 schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
471 false,
472 ),
473 descriptor(
474 "glass.process.list",
475 "List managed processes",
476 schema(serde_json::json!({}), &[]),
477 false,
478 ),
479 descriptor(
480 "glass.git.status",
481 "Inspect code and runtime impact",
482 schema(serde_json::json!({}), &[]),
483 false,
484 ),
485 descriptor(
486 "glass.semantic.inspect",
487 "Inspect source/runtime graph links",
488 schema(serde_json::json!({"entity":{"type":"string"}}), &["entity"]),
489 false,
490 ),
491 descriptor(
492 "glass.test.run",
493 "Run a command as attributed verification",
494 schema(
495 serde_json::json!({"name":{"type":"string"},"command":{"type":"string"}}),
496 &["name", "command"],
497 ),
498 true,
499 ),
500 descriptor(
501 "glass.command.run",
502 "Run one bounded command to completion as the Pi actor",
503 schema(
504 serde_json::json!({"name":{"type":"string"},"command":{"type":"string"},"timeoutSeconds":{"type":"integer"}}),
505 &["name", "command"],
506 ),
507 true,
508 ),
509 descriptor(
510 "glass.diagnostics.run",
511 "Publish bounded rust-analyzer diagnostics for one file",
512 schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
513 false,
514 ),
515 descriptor(
516 "glass.runtime.inspect",
517 "Inspect project, processes, actors, and diagnostics",
518 schema(serde_json::json!({}), &[]),
519 false,
520 ),
521 descriptor(
522 "glass.capabilities.inspect",
523 "Inspect the current Glass agent tool inventory and unavailable reasons",
524 schema(serde_json::json!({}), &[]),
525 false,
526 ),
527 descriptor(
528 "glass.web_ir.inspect",
529 "Validate and inspect one bounded Web IR document",
530 schema(serde_json::json!({"ir":{"type":"object"}}), &["ir"]),
531 false,
532 ),
533 descriptor(
534 "glass.web_ir.diff",
535 "Summarize a validated Web IR revision transition",
536 schema(
537 serde_json::json!({"before":{"type":"object"},"after":{"type":"object"}}),
538 &["before", "after"],
539 ),
540 false,
541 ),
542 descriptor(
543 "glass.web_ir.continuity",
544 "Classify graph-scoped entity continuity across two Web IR revisions",
545 schema(
546 serde_json::json!({"before":{"type":"object"},"after":{"type":"object"},"entityId":{"type":"string"}}),
547 &["before", "after", "entityId"],
548 ),
549 false,
550 ),
551 descriptor(
552 "glass.task.plan",
553 "Compile a value-free task and return a compact explanation",
554 schema(
555 serde_json::json!({"task":{"type":"object"},"ir":{"type":"object"}}),
556 &["task", "ir"],
557 ),
558 false,
559 ),
560 unavailable_descriptor(
561 "glass.browser.observe",
562 "Requires an attached Browser Workspace; structured observation remains the default",
563 ),
564 unavailable_descriptor(
565 "glass.browser.navigate",
566 "Requires an attached Browser Workspace and navigation policy",
567 ),
568 unavailable_descriptor(
569 "glass.browser.act",
570 "Requires an attached Browser Workspace and mutation lease",
571 ),
572 unavailable_descriptor(
573 "glass.workflow.pause",
574 "Requires an active browser workflow run",
575 ),
576 unavailable_descriptor(
577 "glass.workflow.resume",
578 "Requires an active browser workflow checkpoint",
579 ),
580 unavailable_descriptor(
581 "glass.memory.retrieve",
582 "Requires an attached profile-scoped semantic memory store",
583 ),
584 ]
585 }
586
587 fn execute_unchecked(
588 &self,
589 workspace: &mut ProjectWorkspace,
590 call: &ToolCall,
591 actor: Actor,
592 ) -> DevelopmentResult<Value> {
593 let string = |name: &str| {
594 call.arguments
595 .get(name)
596 .and_then(Value::as_str)
597 .ok_or_else(|| {
598 DevelopmentError::InvalidInput(format!(
599 "{} requires string argument {name}",
600 call.name
601 ))
602 })
603 };
604 match call.name.as_str() {
605 "glass.file.read" => read_tool_file(workspace, call, string("path")?),
606 "glass.file.list" => list_tool_files(workspace, call),
607 "glass.file.search" => Ok(serde_json::to_value(
608 workspace.search(string("query")?, 64)?,
609 )?),
610 "glass.file.grep" => grep_tool_files(workspace, call, string("pattern")?),
611 "glass.file.find" => find_tool_files(workspace, call, string("pattern")?),
612 "glass.file.patch" => {
613 let count = workspace.replace_in_buffer(
614 string("path")?,
615 string("search")?,
616 string("replace")?,
617 actor,
618 )?;
619 if count == 0 {
620 return Err(DevelopmentError::Conflict(
621 "patch search text was not found".into(),
622 ));
623 }
624 let path = string("path")?.to_string();
625 let buffer = workspace.save_buffer(&path)?;
626 Ok(serde_json::json!({"path": path, "replacements": count, "dirty": buffer.dirty}))
627 }
628 "glass.file.edit" => execute_atomic_edits(workspace, call, actor),
629 "glass.file.write" => {
630 let path = string("path")?.to_string();
631 workspace.write_file(&path, string("content")?, actor)?;
632 Ok(serde_json::json!({"path":path,"written":true}))
633 }
634 "glass.file.mkdir" => {
635 let path = string("path")?.to_string();
636 workspace.create_directory(&path, actor)?;
637 Ok(serde_json::json!({"path":path,"created":true}))
638 }
639 "glass.file.rename" => {
640 let from = string("from")?.to_string();
641 let to = string("to")?.to_string();
642 workspace.rename_path(&from, &to, actor)?;
643 Ok(serde_json::json!({"from":from,"to":to,"renamed":true}))
644 }
645 "glass.file.delete" => {
646 let path = string("path")?.to_string();
647 workspace.delete_path(&path, actor)?;
648 Ok(serde_json::json!({"path":path,"deleted":true}))
649 }
650 "glass.process.start" => Ok(serde_json::to_value(
651 workspace.start_process(string("name")?, string("command")?)?,
652 )?),
653 "glass.process.stop" => Ok(serde_json::to_value(
654 workspace.stop_process(string("name")?)?,
655 )?),
656 "glass.process.logs" => {
657 Ok(serde_json::json!({"output": workspace.processes().output(string("name")?)?}))
658 }
659 "glass.process.list" => {
660 Ok(serde_json::to_value(workspace.processes().list_checked()?)?)
661 }
662 "glass.git.status" => Ok(serde_json::to_value(workspace.diff()?)?),
663 "glass.semantic.inspect" => Ok(serde_json::to_value(
664 workspace.graph().links_for(string("entity")?),
665 )?),
666 "glass.test.run" => Ok(serde_json::to_value(workspace.run_verification(
667 string("name")?,
668 string("command")?,
669 Duration::from_secs(120),
670 )?)?),
671 "glass.command.run" => {
672 let timeout = call
673 .arguments
674 .get("timeoutSeconds")
675 .and_then(Value::as_u64)
676 .unwrap_or(120);
677 if !(1..=300).contains(&timeout) {
678 return Err(DevelopmentError::InvalidInput(
679 "glass.command.run timeoutSeconds must be between 1 and 300".into(),
680 ));
681 }
682 Ok(serde_json::to_value(workspace.run_command_to_completion(
683 string("name")?,
684 string("command")?,
685 Duration::from_secs(timeout),
686 )?)?)
687 }
688 "glass.diagnostics.run" => Ok(serde_json::to_value(
689 workspace.publish_rust_diagnostics(string("path")?)?,
690 )?),
691 "glass.runtime.inspect" => Ok(serde_json::json!({
692 "project": workspace.detection(),
693 "processes": workspace.processes().list_checked()?,
694 "actors": workspace.actors().collect::<Vec<_>>(),
695 "diagnostics": workspace.diagnostics(),
696 "revision": workspace.revision()
697 })),
698 "glass.web_ir.inspect" => {
699 let ir: glass_browser::web_ir::GlassWebIrV1 =
700 serde_json::from_value(call.arguments["ir"].clone())?;
701 ir.validate().map_err(|error| {
702 DevelopmentError::InvalidInput(format!("invalid Web IR: {error}"))
703 })?;
704 Ok(serde_json::to_value(
705 glass_browser::protocol::WebIrInspectionResult::from_ir(&ir),
706 )?)
707 }
708 "glass.web_ir.diff" => {
709 let before: glass_browser::web_ir::GlassWebIrV1 =
710 serde_json::from_value(call.arguments["before"].clone())?;
711 let after: glass_browser::web_ir::GlassWebIrV1 =
712 serde_json::from_value(call.arguments["after"].clone())?;
713 let diff = before.diff(&after).map_err(|error| {
714 DevelopmentError::InvalidInput(format!("invalid Web IR transition: {error}"))
715 })?;
716 Ok(serde_json::json!({
717 "fromRevision": diff.from_revision,
718 "toRevision": diff.to_revision,
719 "entityChanges": diff.entity_changes.len(),
720 "relationshipChanges": diff.relationship_changes.len(),
721 "coverageChanged": diff.coverage_changed,
722 "limitsChanged": diff.limits_changed
723 }))
724 }
725 "glass.web_ir.continuity" => {
726 let before: glass_browser::web_ir::GlassWebIrV1 =
727 serde_json::from_value(call.arguments["before"].clone())?;
728 let after: glass_browser::web_ir::GlassWebIrV1 =
729 serde_json::from_value(call.arguments["after"].clone())?;
730 let entity_id = string("entityId")?;
731 Ok(serde_json::to_value(
732 before
733 .classify_entity_continuity(&after, entity_id)
734 .map_err(|error| {
735 DevelopmentError::InvalidInput(format!(
736 "invalid Web IR transition: {error}"
737 ))
738 })?,
739 )?)
740 }
741 "glass.task.plan" => {
742 let task: glass_browser::task_protocol::GlassTask =
743 serde_json::from_value(call.arguments["task"].clone())?;
744 let ir: glass_browser::web_ir::GlassWebIrV1 =
745 serde_json::from_value(call.arguments["ir"].clone())?;
746 let plan =
747 glass_browser::task_compiler::compile_task(&task, &ir).map_err(|error| {
748 DevelopmentError::InvalidInput(format!("task compilation failed: {error}"))
749 })?;
750 Ok(serde_json::json!({
751 "sourceRevision": plan.source_ir_revision,
752 "task": plan.task,
753 "risk": plan.risk,
754 "confirmationRequired": plan.confirmation_required,
755 "selectedEntityIds": plan.selected_entity_ids,
756 "requiredRuntimeCapabilities": plan.required_runtime_capabilities,
757 "entityEvidenceRequirements": plan.entity_evidence_requirements,
758 "steps": plan.steps,
759 "postconditions": plan.postconditions
760 }))
761 }
762 _ => Err(DevelopmentError::NotFound(format!("tool {}", call.name))),
763 }
764 }
765}
766
767struct ToolArgumentEvidence {
768 bytes: usize,
769 sha256: String,
770}
771
772struct BoundedJsonWriter {
773 limit: usize,
774 bytes: usize,
775 exceeded: bool,
776 digest: Sha256,
777}
778
779impl BoundedJsonWriter {
780 fn new(limit: usize) -> Self {
781 Self {
782 limit,
783 bytes: 0,
784 exceeded: false,
785 digest: Sha256::new(),
786 }
787 }
788
789 fn evidence(self) -> ToolArgumentEvidence {
790 let digest = self.digest.finalize();
791 ToolArgumentEvidence {
792 bytes: self.bytes,
793 sha256: digest_hex(&digest),
794 }
795 }
796}
797
798impl Write for BoundedJsonWriter {
799 fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
800 let remaining = self.limit.saturating_sub(self.bytes);
801 if buffer.len() > remaining {
802 self.bytes = self.bytes.saturating_add(buffer.len());
803 self.exceeded = true;
804 return Err(std::io::Error::other("bounded JSON limit exceeded"));
805 }
806 self.bytes += buffer.len();
807 self.digest.update(buffer);
808 Ok(buffer.len())
809 }
810
811 fn flush(&mut self) -> std::io::Result<()> {
812 Ok(())
813 }
814}
815
816fn read_tool_file(
817 workspace: &mut ProjectWorkspace,
818 call: &ToolCall,
819 path: &str,
820) -> DevelopmentResult<Value> {
821 let content = workspace.read_file(path)?;
822 let content_sha256 = digest_hex(&Sha256::digest(content.as_bytes()));
823 let offset = call
824 .arguments
825 .get("offset")
826 .and_then(Value::as_u64)
827 .unwrap_or(1);
828 let limit = call
829 .arguments
830 .get("limit")
831 .and_then(Value::as_u64)
832 .unwrap_or(500);
833 if offset == 0 || !(1..=2_000).contains(&limit) {
834 return Err(DevelopmentError::InvalidInput(
835 "glass.file.read offset must be positive and limit must be between 1 and 2000".into(),
836 ));
837 }
838 let total_lines = content
839 .lines()
840 .count()
841 .max(usize::from(!content.is_empty())) as u64;
842 let mut selected = content
843 .split_inclusive('\n')
844 .skip(offset.saturating_sub(1) as usize)
845 .take(limit as usize)
846 .collect::<String>();
847 let selected_lines = selected.lines().count() as u64;
848 let mut bytes_truncated = false;
849 if selected.len() > 60 * 1024 {
850 let mut boundary = 60 * 1024;
851 while !selected.is_char_boundary(boundary) {
852 boundary -= 1;
853 }
854 selected.truncate(boundary);
855 bytes_truncated = true;
856 }
857 Ok(serde_json::json!({
858 "path": path,
859 "content": selected,
860 "offset": offset,
861 "lines": selected_lines,
862 "totalLines": total_lines,
863 "sha256": content_sha256,
864 "truncated": bytes_truncated || offset.saturating_sub(1) + selected_lines < total_lines,
865 }))
866}
867
868fn list_tool_files(workspace: &ProjectWorkspace, call: &ToolCall) -> DevelopmentResult<Value> {
869 let path_prefix = optional_string_argument(call, "path")
870 .map(|path| path.trim_matches('/').to_string())
871 .unwrap_or_default();
872 let limit = bounded_u64_argument(call, "limit", 1, 2_000, 500)? as usize;
873 let tree = workspace.list_files_result()?;
874 let mut entries = Vec::new();
875 let mut truncated = tree.truncated;
876 for entry in tree.entries {
877 if !path_prefix.is_empty()
878 && entry.path != path_prefix
879 && !entry.path.starts_with(&format!("{path_prefix}/"))
880 {
881 continue;
882 }
883 entries.push(entry);
884 if entries.len() == limit {
885 truncated = true;
886 break;
887 }
888 }
889 Ok(serde_json::json!({
890 "entries": entries,
891 "limit": limit,
892 "truncated": truncated,
893 "ignoredDirectories": tree.ignored_directories,
894 "skippedSymlinks": tree.skipped_symlinks,
895 }))
896}
897
898fn grep_tool_files(
899 workspace: &mut ProjectWorkspace,
900 call: &ToolCall,
901 pattern: &str,
902) -> DevelopmentResult<Value> {
903 if pattern.is_empty() {
904 return Err(DevelopmentError::InvalidInput(
905 "glass.file.grep pattern must not be empty".into(),
906 ));
907 }
908 let path_prefix = optional_string_argument(call, "path")
909 .map(|path| path.trim_matches('/').to_string())
910 .unwrap_or_default();
911 let glob = optional_string_argument(call, "glob");
912 let ignore_case = call
913 .arguments
914 .get("ignoreCase")
915 .and_then(Value::as_bool)
916 .unwrap_or(false);
917 let context = bounded_u64_argument(call, "context", 0, 10, 0)? as usize;
918 let limit = bounded_u64_argument(call, "limit", 1, 500, 100)? as usize;
919 let needle = ignore_case.then(|| pattern.to_lowercase());
920 let entries = workspace.list_files_result()?;
921 let mut matches = Vec::new();
922 let mut files_searched = 0usize;
923 let mut bytes_searched = 0u64;
924 let mut files_skipped = 0usize;
925 let mut truncated = entries.truncated;
926 for entry in entries.entries {
927 if entry.kind != super::project::FileKind::File
928 || (!path_prefix.is_empty()
929 && entry.path != path_prefix
930 && !entry.path.starts_with(&format!("{path_prefix}/")))
931 || glob.is_some_and(|glob| !wildcard_matches(glob, &entry.path))
932 {
933 continue;
934 }
935 let bytes = entry.bytes.unwrap_or(0);
936 if files_searched == MAX_GREP_FILES || bytes_searched.saturating_add(bytes) > MAX_GREP_BYTES
937 {
938 truncated = true;
939 break;
940 }
941 let Ok(content) = workspace.read_file_snapshot(&entry.path) else {
942 files_skipped += 1;
943 continue;
944 };
945 files_searched += 1;
946 bytes_searched = bytes_searched.saturating_add(content.len() as u64);
947 let lines = content.lines().collect::<Vec<_>>();
948 for (index, line) in lines.iter().enumerate() {
949 let found = needle.as_ref().map_or_else(
950 || line.contains(pattern),
951 |needle| line.to_lowercase().contains(needle),
952 );
953 if !found {
954 continue;
955 }
956 let start = index.saturating_sub(context);
957 let end = (index + context + 1).min(lines.len());
958 matches.push(serde_json::json!({
959 "path": entry.path,
960 "line": index + 1,
961 "text": line,
962 "contextBefore": lines[start..index],
963 "contextAfter": lines[index + 1..end],
964 }));
965 if matches.len() == limit {
966 return Ok(serde_json::json!({
967 "matches": matches,
968 "filesSearched": files_searched,
969 "bytesSearched": bytes_searched,
970 "filesSkipped": files_skipped,
971 "limit": limit,
972 "truncated": true,
973 "literal": true,
974 }));
975 }
976 }
977 }
978 Ok(serde_json::json!({
979 "matches": matches,
980 "filesSearched": files_searched,
981 "bytesSearched": bytes_searched,
982 "filesSkipped": files_skipped,
983 "limit": limit,
984 "truncated": truncated,
985 "literal": true,
986 }))
987}
988
989fn find_tool_files(
990 workspace: &ProjectWorkspace,
991 call: &ToolCall,
992 pattern: &str,
993) -> DevelopmentResult<Value> {
994 if pattern.is_empty() {
995 return Err(DevelopmentError::InvalidInput(
996 "glass.file.find pattern must not be empty".into(),
997 ));
998 }
999 let path_prefix = optional_string_argument(call, "path")
1000 .map(|path| path.trim_matches('/').to_string())
1001 .unwrap_or_default();
1002 let limit = bounded_u64_argument(call, "limit", 1, 2_000, 500)? as usize;
1003 let tree = workspace.list_files_result()?;
1004 let mut paths = Vec::new();
1005 let mut truncated = tree.truncated;
1006 for entry in tree.entries {
1007 if (!path_prefix.is_empty()
1008 && entry.path != path_prefix
1009 && !entry.path.starts_with(&format!("{path_prefix}/")))
1010 || !wildcard_matches(pattern, &entry.path)
1011 {
1012 continue;
1013 }
1014 paths.push(serde_json::json!({"path":entry.path,"kind":entry.kind}));
1015 if paths.len() == limit {
1016 truncated = true;
1017 break;
1018 }
1019 }
1020 Ok(serde_json::json!({"paths":paths,"limit":limit,"truncated":truncated}))
1021}
1022
1023fn optional_string_argument<'a>(call: &'a ToolCall, name: &str) -> Option<&'a str> {
1024 call.arguments.get(name).and_then(Value::as_str)
1025}
1026
1027fn bounded_u64_argument(
1028 call: &ToolCall,
1029 name: &str,
1030 minimum: u64,
1031 maximum: u64,
1032 default: u64,
1033) -> DevelopmentResult<u64> {
1034 let value = call
1035 .arguments
1036 .get(name)
1037 .and_then(Value::as_u64)
1038 .unwrap_or(default);
1039 if !(minimum..=maximum).contains(&value) {
1040 return Err(DevelopmentError::InvalidInput(format!(
1041 "{} {name} must be between {minimum} and {maximum}",
1042 call.name
1043 )));
1044 }
1045 Ok(value)
1046}
1047
1048fn wildcard_matches(pattern: &str, value: &str) -> bool {
1049 let pattern = pattern.chars().collect::<Vec<_>>();
1050 let value = value.chars().collect::<Vec<_>>();
1051 let (mut pattern_index, mut value_index) = (0usize, 0usize);
1052 let (mut star, mut retry) = (None, 0usize);
1053 while value_index < value.len() {
1054 if pattern_index < pattern.len()
1055 && (pattern[pattern_index] == '?' || pattern[pattern_index] == value[value_index])
1056 {
1057 pattern_index += 1;
1058 value_index += 1;
1059 } else if pattern_index < pattern.len() && pattern[pattern_index] == '*' {
1060 star = Some(pattern_index);
1061 pattern_index += 1;
1062 retry = value_index;
1063 } else if let Some(star_index) = star {
1064 pattern_index = star_index + 1;
1065 retry += 1;
1066 value_index = retry;
1067 } else {
1068 return false;
1069 }
1070 }
1071 while pattern_index < pattern.len() && pattern[pattern_index] == '*' {
1072 pattern_index += 1;
1073 }
1074 pattern_index == pattern.len()
1075}
1076
1077fn execute_atomic_edits(
1078 workspace: &mut ProjectWorkspace,
1079 call: &ToolCall,
1080 actor: Actor,
1081) -> DevelopmentResult<Value> {
1082 let path = call.arguments["path"]
1083 .as_str()
1084 .ok_or_else(|| DevelopmentError::InvalidInput("glass.file.edit requires path".into()))?;
1085 let edits = call.arguments["edits"]
1086 .as_array()
1087 .filter(|edits| !edits.is_empty() && edits.len() <= 64)
1088 .ok_or_else(|| {
1089 DevelopmentError::InvalidInput("glass.file.edit requires between 1 and 64 edits".into())
1090 })?;
1091 let original = workspace.read_file(path)?;
1092 let mut replacements = Vec::with_capacity(edits.len());
1093 for edit in edits {
1094 let old_text = edit.get("oldText").and_then(Value::as_str).ok_or_else(|| {
1095 DevelopmentError::InvalidInput("every edit requires string oldText".into())
1096 })?;
1097 let new_text = edit.get("newText").and_then(Value::as_str).ok_or_else(|| {
1098 DevelopmentError::InvalidInput("every edit requires string newText".into())
1099 })?;
1100 if old_text.is_empty() {
1101 return Err(DevelopmentError::InvalidInput(
1102 "glass.file.edit oldText must not be empty".into(),
1103 ));
1104 }
1105 let matches = original.match_indices(old_text).collect::<Vec<_>>();
1106 if matches.len() != 1 {
1107 return Err(DevelopmentError::Conflict(format!(
1108 "glass.file.edit oldText must match exactly once; matched {} times",
1109 matches.len()
1110 )));
1111 }
1112 let start = matches[0].0;
1113 replacements.push((start, start + old_text.len(), new_text));
1114 }
1115 replacements.sort_by_key(|replacement| replacement.0);
1116 if replacements.windows(2).any(|pair| pair[0].1 > pair[1].0) {
1117 return Err(DevelopmentError::Conflict(
1118 "glass.file.edit replacements overlap".into(),
1119 ));
1120 }
1121 let mut content = original;
1122 for (start, end, new_text) in replacements.iter().rev() {
1123 content.replace_range(*start..*end, new_text);
1124 }
1125 workspace.edit_buffer(path, content, actor)?;
1126 let buffer = workspace.save_buffer(path)?;
1127 Ok(serde_json::json!({
1128 "path": path,
1129 "replacements": replacements.len(),
1130 "dirty": buffer.dirty,
1131 }))
1132}
1133
1134fn validate_tool_call_envelope(call: &ToolCall) -> DevelopmentResult<()> {
1135 if call.id.is_empty()
1136 || call.id.len() > MAX_TOOL_CALL_ID_BYTES
1137 || call.id.chars().any(char::is_control)
1138 {
1139 return Err(DevelopmentError::InvalidInput(format!(
1140 "tool call id must contain 1 to {MAX_TOOL_CALL_ID_BYTES} non-control bytes"
1141 )));
1142 }
1143 if call.name.is_empty()
1144 || call.name.len() > MAX_TOOL_NAME_BYTES
1145 || !call
1146 .name
1147 .bytes()
1148 .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
1149 {
1150 return Err(DevelopmentError::InvalidInput(format!(
1151 "tool name must contain 1 to {MAX_TOOL_NAME_BYTES} ASCII identifier bytes"
1152 )));
1153 }
1154 Ok(())
1155}
1156
1157fn validate_tool_arguments(
1158 descriptor: &ToolDescriptor,
1159 arguments: &Value,
1160) -> DevelopmentResult<ToolArgumentEvidence> {
1161 let mut writer = BoundedJsonWriter::new(MAX_TOOL_ARGUMENT_BYTES);
1162 let serialized = serde_json::to_writer(&mut writer, arguments);
1163 if writer.exceeded {
1164 return Err(DevelopmentError::InvalidInput(format!(
1165 "tool arguments exceed the {MAX_TOOL_ARGUMENT_BYTES} byte limit"
1166 )));
1167 }
1168 serialized?;
1169 let object = arguments.as_object().ok_or_else(|| {
1170 DevelopmentError::InvalidInput(format!("{} arguments must be an object", descriptor.name))
1171 })?;
1172 let properties = descriptor.input_schema["properties"]
1173 .as_object()
1174 .cloned()
1175 .unwrap_or_default();
1176 for required in descriptor.input_schema["required"]
1177 .as_array()
1178 .into_iter()
1179 .flatten()
1180 .filter_map(Value::as_str)
1181 {
1182 if !object.contains_key(required) {
1183 return Err(DevelopmentError::InvalidInput(format!(
1184 "{} requires argument {required}",
1185 descriptor.name
1186 )));
1187 }
1188 }
1189 for (name, value) in object {
1190 let Some(property) = properties.get(name) else {
1191 return Err(DevelopmentError::InvalidInput(format!(
1192 "{} does not accept argument {name}",
1193 descriptor.name
1194 )));
1195 };
1196 let valid = match property["type"].as_str() {
1197 Some("string") => value.is_string(),
1198 Some("object") => value.is_object(),
1199 Some("integer") => value.as_u64().is_some(),
1200 _ => true,
1201 };
1202 if !valid {
1203 return Err(DevelopmentError::InvalidInput(format!(
1204 "{}.{} has the wrong type",
1205 descriptor.name, name
1206 )));
1207 }
1208 }
1209 Ok(writer.evidence())
1210}
1211
1212fn tool_call_evidence(call: &ToolCall, mutating: bool, evidence: &ToolArgumentEvidence) -> Value {
1213 serde_json::json!({
1214 "id": call.id,
1215 "name": call.name,
1216 "mutating": mutating,
1217 "argumentBytes": evidence.bytes,
1218 "argumentSha256": evidence.sha256
1219 })
1220}
1221
1222fn digest_hex(bytes: &[u8]) -> String {
1223 const DIGITS: &[u8; 16] = b"0123456789abcdef";
1224 let mut encoded = String::with_capacity(bytes.len() * 2);
1225 for byte in bytes {
1226 encoded.push(DIGITS[(byte >> 4) as usize] as char);
1227 encoded.push(DIGITS[(byte & 0x0f) as usize] as char);
1228 }
1229 encoded
1230}
1231
1232fn descriptor(
1233 name: &str,
1234 description: &str,
1235 input_schema: Value,
1236 mutating: bool,
1237) -> ToolDescriptor {
1238 ToolDescriptor {
1239 name: name.into(),
1240 description: description.into(),
1241 input_schema,
1242 mutating,
1243 available: true,
1244 unavailable_reason: None,
1245 }
1246}
1247
1248fn unavailable_descriptor(name: &str, reason: &str) -> ToolDescriptor {
1249 ToolDescriptor {
1250 name: name.into(),
1251 description: reason.into(),
1252 input_schema: serde_json::json!({"type":"object"}),
1253 mutating: false,
1254 available: false,
1255 unavailable_reason: Some(reason.into()),
1256 }
1257}
1258
1259#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1260#[serde(tag = "type", rename_all = "camelCase")]
1261pub enum HarnessRequest {
1262 Hello,
1263 Prompt { text: String },
1264 Steer { text: String },
1265 FollowUp { text: String },
1266 Abort,
1267 State,
1268 Models,
1269 SetModel { provider: String, model_id: String },
1270 SetThinking { level: String },
1271 NewSession,
1272 Compact { instructions: Option<String> },
1273 CloneSession,
1274 Fork { entry_id: String },
1275 SwitchSession { path: String },
1276 Entries { since: Option<String> },
1277 Messages,
1278 SessionStats,
1279 SetSessionName { name: String },
1280}
1281
1282#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1283#[serde(tag = "type", rename_all = "camelCase")]
1284pub enum HarnessEvent {
1285 Hello {
1286 protocol: String,
1287 actor: Actor,
1288 capabilities: Vec<String>,
1289 },
1290 State {
1291 state: String,
1292 },
1293 Text {
1294 text: String,
1295 },
1296 ToolCall(ToolCall),
1297 ToolResult {
1298 id: String,
1299 result: Value,
1300 },
1301 Error {
1302 message: String,
1303 },
1304}
1305
1306#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1307#[serde(rename_all = "camelCase")]
1308pub struct ToolCall {
1309 pub id: String,
1310 pub name: String,
1311 pub arguments: Value,
1312}
1313
1314#[derive(Debug, Clone)]
1315pub struct LocalHarness {
1316 actor: Actor,
1317 gateway: AgentToolGateway,
1318 next_tool_id: u64,
1319 state: String,
1320 browser_context: Option<BrowserAgentContext>,
1321}
1322
1323impl Default for LocalHarness {
1324 fn default() -> Self {
1325 Self {
1326 actor: Actor::embedded(),
1327 gateway: AgentToolGateway::default(),
1328 next_tool_id: 1,
1329 state: "idle".into(),
1330 browser_context: None,
1331 }
1332 }
1333}
1334
1335impl LocalHarness {
1336 pub fn set_browser_context(&mut self, context: Option<BrowserAgentContext>) {
1337 self.browser_context = context.clone();
1338 self.gateway.set_browser_context(context);
1339 }
1340 pub fn actor(&self) -> &Actor {
1341 &self.actor
1342 }
1343
1344 pub fn handle(
1345 &mut self,
1346 workspace: &mut ProjectWorkspace,
1347 request: HarnessRequest,
1348 ) -> DevelopmentResult<Vec<HarnessEvent>> {
1349 match request {
1350 HarnessRequest::Hello => Ok(vec![HarnessEvent::Hello {
1351 protocol: "glass.harness.v1".into(),
1352 actor: self.actor.clone(),
1353 capabilities: vec![
1354 "prompt".into(),
1355 "stream".into(),
1356 "tool.call".into(),
1357 "steer".into(),
1358 "follow_up".into(),
1359 "abort".into(),
1360 "session.new".into(),
1361 "model.list".into(),
1362 ],
1363 }]),
1364 HarnessRequest::Prompt { text } => self.prompt(workspace, text),
1365 HarnessRequest::Steer { text } => {
1366 let evidence = prompt_evidence(&text);
1367 workspace.record_as(
1368 self.actor.clone(),
1369 DevelopmentEventKind::AgentSteered,
1370 evidence,
1371 )?;
1372 self.state = "steered".into();
1373 Ok(vec![
1374 HarnessEvent::State {
1375 state: self.state.clone(),
1376 },
1377 HarnessEvent::Text {
1378 text: "Steering accepted by the Glass harness.".into(),
1379 },
1380 ])
1381 }
1382 HarnessRequest::Abort => {
1383 self.state = "aborted".into();
1384 Ok(vec![HarnessEvent::State {
1385 state: self.state.clone(),
1386 }])
1387 }
1388 HarnessRequest::FollowUp { text } => self.prompt(workspace, text),
1389 HarnessRequest::State => Ok(vec![HarnessEvent::State {
1390 state: self.state.clone(),
1391 }]),
1392 HarnessRequest::Models => Ok(vec![HarnessEvent::Text {
1393 text: "The local harness has no model provider; configure the Pi adapter.".into(),
1394 }]),
1395 HarnessRequest::SetModel { .. } | HarnessRequest::SetThinking { .. } => {
1396 Ok(vec![HarnessEvent::Error {
1397 message: "model controls require the Pi harness adapter".into(),
1398 }])
1399 }
1400 HarnessRequest::NewSession => {
1401 self.state = "idle".into();
1402 Ok(vec![HarnessEvent::State {
1403 state: self.state.clone(),
1404 }])
1405 }
1406 HarnessRequest::Compact { .. }
1407 | HarnessRequest::CloneSession
1408 | HarnessRequest::Fork { .. }
1409 | HarnessRequest::SwitchSession { .. }
1410 | HarnessRequest::Entries { .. }
1411 | HarnessRequest::Messages
1412 | HarnessRequest::SessionStats
1413 | HarnessRequest::SetSessionName { .. } => Ok(vec![HarnessEvent::Error {
1414 message: "persistent session controls require the Pi runtime".into(),
1415 }]),
1416 }
1417 }
1418
1419 fn prompt(
1420 &mut self,
1421 workspace: &mut ProjectWorkspace,
1422 text: String,
1423 ) -> DevelopmentResult<Vec<HarnessEvent>> {
1424 if text.trim().is_empty() || text.len() > 8 * 1024 {
1425 return Ok(vec![HarnessEvent::Error {
1426 message: "prompt must be non-empty and at most 8192 bytes".into(),
1427 }]);
1428 }
1429 workspace.record_as(
1430 self.actor.clone(),
1431 DevelopmentEventKind::AgentPrompt,
1432 prompt_evidence(&text),
1433 )?;
1434 self.state = "working".into();
1435 let mut events = vec![HarnessEvent::State {
1436 state: self.state.clone(),
1437 }];
1438 let lower = text.to_ascii_lowercase();
1439 if text.split_whitespace().any(|token| token.starts_with('@')) {
1440 let packet =
1441 resolve_context_with_browser(workspace, &text, self.browser_context.as_ref())?;
1442 events.push(HarnessEvent::Text {
1443 text: serde_json::to_string(&packet)?,
1444 });
1445 } else if let Some(path) = text
1446 .strip_prefix("read ")
1447 .map(str::trim)
1448 .filter(|value| !value.is_empty())
1449 {
1450 let call = self.tool_call("glass.file.read", serde_json::json!({"path": path}));
1451 let id = call.id.clone();
1452 events.push(HarnessEvent::ToolCall(call.clone()));
1453 match self.gateway.execute(
1454 workspace,
1455 &call,
1456 &ToolAuthorization::read_only(self.actor.clone()),
1457 ) {
1458 Ok(result) => {
1459 events.push(HarnessEvent::ToolResult { id, result });
1460 }
1461 Err(error) => events.push(HarnessEvent::Error {
1462 message: error.to_string(),
1463 }),
1464 }
1465 } else if lower == "files" || lower == "list files" {
1466 let call = self.tool_call("glass.file.list", serde_json::json!({}));
1467 let id = call.id.clone();
1468 events.push(HarnessEvent::ToolCall(call.clone()));
1469 let result = self.gateway.execute(
1470 workspace,
1471 &call,
1472 &ToolAuthorization::read_only(self.actor.clone()),
1473 )?;
1474 events.push(HarnessEvent::ToolResult { id, result });
1475 } else if lower == "process list" || lower == "processes" {
1476 let call = self.tool_call("glass.process.list", serde_json::json!({}));
1477 let id = call.id.clone();
1478 events.push(HarnessEvent::ToolCall(call.clone()));
1479 let result = self.gateway.execute(
1480 workspace,
1481 &call,
1482 &ToolAuthorization::read_only(self.actor.clone()),
1483 )?;
1484 events.push(HarnessEvent::ToolResult { id, result });
1485 } else if lower == "diff" {
1486 let call = self.tool_call("glass.git.status", serde_json::json!({}));
1487 let id = call.id.clone();
1488 events.push(HarnessEvent::ToolCall(call.clone()));
1489 let result = self.gateway.execute(
1490 workspace,
1491 &call,
1492 &ToolAuthorization::read_only(self.actor.clone()),
1493 )?;
1494 events.push(HarnessEvent::ToolResult { id, result });
1495 } else {
1496 events.push(HarnessEvent::Text {
1497 text: "Glass local harness is ready. Try `read <path>`, `files`, `process list`, or `diff`.".into(),
1498 });
1499 }
1500 self.state = "idle".into();
1501 events.push(HarnessEvent::State {
1502 state: self.state.clone(),
1503 });
1504 Ok(events)
1505 }
1506
1507 fn tool_call(&mut self, name: &str, arguments: Value) -> ToolCall {
1508 let id = format!("tool-{}", self.next_tool_id);
1509 self.next_tool_id = self.next_tool_id.saturating_add(1);
1510 ToolCall {
1511 id,
1512 name: name.into(),
1513 arguments,
1514 }
1515 }
1516}
1517
1518pub struct PiHarness {
1523 child: Child,
1524 input: ChildStdin,
1525 output: Receiver<Value>,
1526 next_id: u64,
1527 extension_path: PathBuf,
1528 pending_ui_requests: BTreeSet<String>,
1529 unrestricted: bool,
1530}
1531
1532#[derive(Debug, Clone, Default)]
1533pub struct PiHarnessOptions {
1534 pub unrestricted: bool,
1535 pub persist_session: bool,
1536 pub session_id: Option<String>,
1537 pub fork: Option<String>,
1538 pub session_dir: Option<PathBuf>,
1539 pub name: Option<String>,
1540 pub model: Option<String>,
1541 pub thinking: Option<String>,
1542 pub broker_socket: Option<PathBuf>,
1543 pub broker_token: Option<String>,
1544 pub broker_workspace_id: Option<String>,
1545 pub additional_system_prompt: Option<String>,
1546}
1547
1548impl std::fmt::Debug for PiHarness {
1549 fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1550 formatter
1551 .debug_struct("PiHarness")
1552 .field("pid", &self.child.id())
1553 .field("next_id", &self.next_id)
1554 .finish()
1555 }
1556}
1557
1558impl PiHarness {
1559 pub fn spawn(root: &Path) -> DevelopmentResult<Self> {
1560 Self::spawn_with_unrestricted(root, false)
1561 }
1562
1563 pub fn spawn_with_unrestricted(root: &Path, unrestricted: bool) -> DevelopmentResult<Self> {
1564 Self::spawn_with_options(
1565 root,
1566 PiHarnessOptions {
1567 unrestricted,
1568 persist_session: env_enabled("GLASS_PI_PERSIST_SESSION"),
1569 ..PiHarnessOptions::default()
1570 },
1571 )
1572 }
1573
1574 pub fn spawn_with_options(root: &Path, options: PiHarnessOptions) -> DevelopmentResult<Self> {
1575 validate_pi_harness_options(&options)?;
1576 static NEXT_EXTENSION_ID: std::sync::atomic::AtomicU64 =
1577 std::sync::atomic::AtomicU64::new(1);
1578 let extension_id = NEXT_EXTENSION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1579 let extension_path = std::env::temp_dir().join(format!(
1580 "glass-pi-tools-{}-{extension_id}.ts",
1581 std::process::id()
1582 ));
1583 std::fs::write(
1584 &extension_path,
1585 include_str!("../../assets/pi-glass-tools.ts"),
1586 )?;
1587 let broker = std::env::current_exe().map_err(DevelopmentError::Io)?;
1588 let trusted_resources = options.unrestricted || env_enabled("GLASS_PI_TRUSTED_RESOURCES");
1589 let mut system_prompt = if options.unrestricted {
1590 format!(
1591 "{}\n- UNRESTRICTED MODE is active. Glass will not ask for tool approval; execute requested local development work directly and report effects truthfully.",
1592 include_str!("../../assets/pi-glass-system.md")
1593 )
1594 } else {
1595 include_str!("../../assets/pi-glass-system.md").to_string()
1596 };
1597 if let Some(additional) = &options.additional_system_prompt {
1598 if additional.len() > 128 * 1024 || additional.contains('\0') {
1599 return Err(DevelopmentError::InvalidInput(
1600 "additional Pi system prompt exceeds 128 KiB or contains NUL".into(),
1601 ));
1602 }
1603 system_prompt.push_str(additional);
1604 }
1605 let mut command = Command::new("pi");
1606 command.args(["--mode", "rpc", "--no-approve", "--no-builtin-tools"]);
1607 if !env_enabled("GLASS_PI_ONLINE_CATALOG") {
1608 command.arg("--offline");
1609 }
1610 if !trusted_resources {
1611 command.args([
1612 "--no-context-files",
1613 "--no-extensions",
1614 "--no-skills",
1615 "--no-prompt-templates",
1616 "--no-themes",
1617 ]);
1618 }
1619 if !options.persist_session {
1620 command.arg("--no-session");
1621 }
1622 if let Some(session_id) = &options.session_id {
1623 command.args(["--session-id", session_id]);
1624 }
1625 if let Some(fork) = &options.fork {
1626 command.args(["--fork", fork]);
1627 }
1628 if let Some(session_dir) = &options.session_dir {
1629 std::fs::create_dir_all(session_dir)?;
1630 command.arg("--session-dir").arg(session_dir);
1631 }
1632 if let Some(name) = &options.name {
1633 command.args(["--name", name]);
1634 }
1635 if let Some(model) = &options.model {
1636 command.args(["--model", model]);
1637 }
1638 if let Some(thinking) = &options.thinking {
1639 command.args(["--thinking", thinking]);
1640 }
1641 if let Some(socket) = &options.broker_socket {
1642 command.env("GLASS_DEV_DAEMON_SOCKET", socket);
1643 }
1644 if let Some(token) = &options.broker_token {
1645 command.env("GLASS_DEV_DAEMON_TOKEN", token);
1646 }
1647 if let Some(workspace_id) = &options.broker_workspace_id {
1648 command.env("GLASS_DEV_DAEMON_WORKSPACE", workspace_id);
1649 }
1650 command
1651 .args(["--system-prompt", &system_prompt, "--extension"])
1652 .arg(&extension_path);
1653 if !trusted_resources {
1654 command.arg("--tools").arg(
1655 [
1656 "read",
1657 "write",
1658 "edit",
1659 "bash",
1660 "grep",
1661 "find",
1662 "ls",
1663 "glass_git_status",
1664 "glass_semantic_inspect",
1665 "glass_web_ir_inspect",
1666 "glass_web_ir_diff",
1667 "glass_web_ir_continuity",
1668 "glass_task_plan",
1669 "glass_runtime_inspect",
1670 "glass_capabilities",
1671 "glass_diagnostics_run",
1672 "glass_file_mkdir",
1673 "glass_file_rename",
1674 "glass_file_delete",
1675 "glass_test_run",
1676 "glass_process_list",
1677 "glass_process_start",
1678 "glass_process_stop",
1679 "glass_process_logs",
1680 "glass_process_restart",
1681 "glass_process_input",
1682 "glass_process_resize",
1683 "glass_process_health",
1684 "glass_process_ports",
1685 "glass_editor_open",
1686 "glass_editor_selection",
1687 "glass_editor_replace",
1688 "glass_editor_save",
1689 "glass_editor_diff",
1690 "glass_editor_buffers",
1691 "glass_browser_state",
1692 "glass_browser_start",
1693 "glass_browser_stop",
1694 "glass_browser_observe",
1695 "glass_browser_targets",
1696 "glass_browser_select_target",
1697 "glass_browser_navigate",
1698 "glass_browser_act",
1699 "glass_browser_screenshot",
1700 "glass_workflow_run",
1701 "glass_workflow_pause",
1702 "glass_workflow_resume",
1703 "glass_git_diff",
1704 "glass_git_stage",
1705 "glass_git_unstage",
1706 "glass_git_commit",
1707 "glass_git_branches",
1708 "glass_git_branch_create",
1709 "glass_git_branch_switch",
1710 "glass_git_blame",
1711 "glass_git_worktrees",
1712 "glass_git_worktree_create",
1713 "glass_git_worktree_remove",
1714 "glass_test_discover",
1715 "glass_test_run_suite",
1716 "glass_test_results",
1717 "glass_test_cancel",
1718 "glass_test_watch",
1719 "glass_eval_start",
1720 "glass_eval_execute",
1721 "glass_eval_list",
1722 "glass_eval_reset",
1723 "glass_eval_stop",
1724 "glass_lsp_diagnostics",
1725 "glass_lsp_hover",
1726 "glass_lsp_completion",
1727 "glass_lsp_definition",
1728 "glass_lsp_declaration",
1729 "glass_lsp_implementation",
1730 "glass_lsp_references",
1731 "glass_lsp_document_symbols",
1732 "glass_lsp_workspace_symbols",
1733 "glass_lsp_signature_help",
1734 "glass_lsp_code_actions",
1735 "glass_lsp_formatting",
1736 "glass_lsp_range_formatting",
1737 "glass_lsp_semantic_tokens",
1738 "glass_lsp_rename",
1739 "glass_debug_start",
1740 "glass_debug_launch",
1741 "glass_debug_attach",
1742 "glass_debug_breakpoint_set",
1743 "glass_debug_continue",
1744 "glass_debug_pause",
1745 "glass_debug_step",
1746 "glass_debug_stack",
1747 "glass_debug_scopes",
1748 "glass_debug_variables",
1749 "glass_debug_evaluate",
1750 "glass_debug_events",
1751 "glass_debug_stop",
1752 "glass_agent_list",
1753 "glass_agent_spawn",
1754 "glass_agent_prompt",
1755 "glass_agent_steer",
1756 "glass_agent_follow_up",
1757 "glass_agent_abort",
1758 "glass_agent_compact",
1759 "glass_agent_model",
1760 "glass_agent_thinking",
1761 "glass_agent_new_session",
1762 "glass_agent_clone_session",
1763 "glass_agent_fork",
1764 "glass_agent_switch_session",
1765 "glass_agent_messages",
1766 "glass_agent_entries",
1767 "glass_agent_stats",
1768 "glass_agent_name",
1769 "glass_graph_query",
1770 "glass_graph_path",
1771 "glass_replay_list",
1772 "glass_replay_diff",
1773 ]
1774 .join(","),
1775 );
1776 }
1777 let mut child = command
1778 .env("GLASS_PI_BROKER_BIN", broker)
1779 .env(
1780 "GLASS_PI_YOLO",
1781 if options.unrestricted { "1" } else { "0" },
1782 )
1783 .current_dir(root)
1784 .stdin(Stdio::piped())
1785 .stdout(Stdio::piped())
1786 .stderr(Stdio::null())
1787 .spawn()
1788 .map_err(|error| DevelopmentError::Process(format!("failed to start Pi: {error}")))?;
1789 let input = child
1790 .stdin
1791 .take()
1792 .ok_or_else(|| DevelopmentError::Process("Pi stdin is unavailable".into()))?;
1793 let output = child
1794 .stdout
1795 .take()
1796 .ok_or_else(|| DevelopmentError::Process("Pi stdout is unavailable".into()))?;
1797 let (sender, receiver) = mpsc::sync_channel(PI_EVENT_CHANNEL_CAPACITY);
1798 thread::Builder::new()
1799 .name("glass-pi-rpc".into())
1800 .spawn(move || {
1801 for line in BufReader::new(output).split(b'\n') {
1802 let Ok(mut line) = line else { break };
1803 if line.last() == Some(&b'\r') {
1804 line.pop();
1805 }
1806 if line.len() > MAX_PI_EVENT_BYTES {
1807 continue;
1808 }
1809 if let Ok(value) = serde_json::from_slice::<Value>(&line)
1810 && sender.send(value).is_err()
1811 {
1812 break;
1813 }
1814 }
1815 })
1816 .map_err(DevelopmentError::Io)?;
1817 Ok(Self {
1818 child,
1819 input,
1820 output: receiver,
1821 next_id: 1,
1822 extension_path,
1823 pending_ui_requests: BTreeSet::new(),
1824 unrestricted: options.unrestricted,
1825 })
1826 }
1827
1828 pub fn request(&mut self, request: HarnessRequest) -> DevelopmentResult<Vec<Value>> {
1829 let wait_for_agent = matches!(request, HarnessRequest::Prompt { .. });
1830 let id = self.start_request(request)?;
1831 let mut events = VecDeque::with_capacity(MAX_PI_BUFFERED_EVENTS);
1832 let mut response_received = false;
1833 let mut observed = 0_usize;
1834 loop {
1835 let value = self
1836 .recv_event_timeout(if response_received {
1837 Duration::from_secs(120)
1838 } else {
1839 Duration::from_secs(10)
1840 })?
1841 .ok_or_else(|| {
1842 DevelopmentError::Process(if response_received {
1843 "Pi agent event stream timed out".into()
1844 } else {
1845 "Pi RPC response timed out".into()
1846 })
1847 })?;
1848 observed = observed.saturating_add(1);
1849 let is_response = pi_response_matches(&value, &id);
1850 let failed =
1851 is_response && value.get("success").and_then(Value::as_bool) == Some(false);
1852 let settled = pi_agent_settled(&value);
1853 if let Some(request) = pi_ui_request(&value)? {
1854 if !self.unrestricted {
1855 self.respond_extension_ui(&request.id, false)?;
1859 }
1860 continue;
1861 }
1862 if pi_event_visible(&value) {
1863 if events.len() == MAX_PI_BUFFERED_EVENTS {
1864 events.pop_front();
1865 }
1866 events.push_back(value);
1867 }
1868 if failed {
1869 return Err(DevelopmentError::Process(format!(
1870 "Pi rejected RPC command {id}"
1871 )));
1872 }
1873 if is_response {
1874 response_received = true;
1875 if !wait_for_agent {
1876 return Ok(events.into());
1877 }
1878 }
1879 if response_received && settled {
1880 return Ok(events.into());
1881 }
1882 if observed >= 4096 {
1883 return Err(DevelopmentError::Process(
1884 "Pi emitted too many events before settling".into(),
1885 ));
1886 }
1887 }
1888 }
1889
1890 pub fn start_request(&mut self, request: HarnessRequest) -> DevelopmentResult<String> {
1891 let (command, private_text) = match request {
1892 HarnessRequest::Hello | HarnessRequest::State => {
1893 (serde_json::json!({"type": "get_state"}), None)
1894 }
1895 HarnessRequest::Prompt { text } => (
1896 serde_json::json!({"type": "prompt", "message": text}),
1897 Some(()),
1898 ),
1899 HarnessRequest::Steer { text } => (
1900 serde_json::json!({"type": "steer", "message": text}),
1901 Some(()),
1902 ),
1903 HarnessRequest::FollowUp { text } => (
1904 serde_json::json!({"type": "follow_up", "message": text}),
1905 Some(()),
1906 ),
1907 HarnessRequest::Abort => (serde_json::json!({"type": "abort"}), None),
1908 HarnessRequest::Models => (serde_json::json!({"type": "get_available_models"}), None),
1909 HarnessRequest::SetModel { provider, model_id } => (
1910 serde_json::json!({"type": "set_model", "provider": provider, "modelId": model_id}),
1911 None,
1912 ),
1913 HarnessRequest::SetThinking { level } => (
1914 serde_json::json!({"type": "set_thinking_level", "level": level}),
1915 None,
1916 ),
1917 HarnessRequest::NewSession => (serde_json::json!({"type": "new_session"}), None),
1918 HarnessRequest::Compact { instructions } => (
1919 serde_json::json!({"type": "compact", "customInstructions": instructions}),
1920 None,
1921 ),
1922 HarnessRequest::CloneSession => (serde_json::json!({"type": "clone"}), None),
1923 HarnessRequest::Fork { entry_id } => (
1924 serde_json::json!({"type": "fork", "entryId": entry_id}),
1925 None,
1926 ),
1927 HarnessRequest::SwitchSession { path } => (
1928 serde_json::json!({"type": "switch_session", "sessionPath": path}),
1929 None,
1930 ),
1931 HarnessRequest::Entries { since } => (
1932 serde_json::json!({"type": "get_entries", "since": since}),
1933 None,
1934 ),
1935 HarnessRequest::Messages => (serde_json::json!({"type": "get_messages"}), None),
1936 HarnessRequest::SessionStats => {
1937 (serde_json::json!({"type": "get_session_stats"}), None)
1938 }
1939 HarnessRequest::SetSessionName { name } => (
1940 serde_json::json!({"type": "set_session_name", "name": name}),
1941 None,
1942 ),
1943 };
1944 let _private_text = private_text;
1945 self.send(command)
1946 }
1947
1948 fn send(&mut self, mut command: Value) -> DevelopmentResult<String> {
1949 let id = format!("glass-{}", self.next_id);
1950 self.next_id = self.next_id.saturating_add(1);
1951 command["id"] = Value::String(id.clone());
1952 let encoded = serde_json::to_vec(&command)?;
1953 if encoded.len() > 1024 * 1024 {
1954 return Err(DevelopmentError::InvalidInput(
1955 "Pi RPC command exceeds the 1 MiB limit".into(),
1956 ));
1957 }
1958 self.input.write_all(&encoded)?;
1959 self.input.write_all(b"\n")?;
1960 self.input.flush()?;
1961 Ok(id)
1962 }
1963
1964 pub fn respond_extension_ui(&mut self, id: &str, confirmed: bool) -> DevelopmentResult<()> {
1965 if !self.pending_ui_requests.remove(id) {
1966 return Err(DevelopmentError::Conflict(format!(
1967 "stale or unknown Pi UI request: {id}"
1968 )));
1969 }
1970 let encoded = serde_json::to_vec(&serde_json::json!({
1971 "type": "extension_ui_response",
1972 "id": id,
1973 "confirmed": confirmed,
1974 }))?;
1975 self.input.write_all(&encoded)?;
1976 self.input.write_all(b"\n")?;
1977 self.input.flush()?;
1978 Ok(())
1979 }
1980
1981 pub fn recv_event_timeout(&mut self, timeout: Duration) -> DevelopmentResult<Option<Value>> {
1982 match self.output.recv_timeout(timeout) {
1983 Ok(value) => {
1984 if let Some(request) = pi_ui_request(&value)?
1985 && !self.pending_ui_requests.insert(request.id.clone())
1986 {
1987 return Err(DevelopmentError::Conflict(format!(
1988 "duplicate Pi UI request: {}",
1989 request.id
1990 )));
1991 }
1992 if self.pending_ui_requests.len() > 8 {
1993 return Err(DevelopmentError::Conflict(
1994 "too many pending Pi UI requests".into(),
1995 ));
1996 }
1997 if self.unrestricted
1998 && let Some(request) = pi_ui_request(&value)?
1999 {
2000 self.respond_extension_ui(&request.id, true)?;
2001 }
2002 Ok(Some(value))
2003 }
2004 Err(RecvTimeoutError::Timeout) => Ok(None),
2005 Err(RecvTimeoutError::Disconnected) => Err(DevelopmentError::Process(
2006 "Pi RPC event stream closed".into(),
2007 )),
2008 }
2009 }
2010}
2011
2012fn validate_pi_harness_options(options: &PiHarnessOptions) -> DevelopmentResult<()> {
2013 let broker_fields = [
2014 options.broker_socket.is_some(),
2015 options.broker_token.is_some(),
2016 options.broker_workspace_id.is_some(),
2017 ];
2018 if broker_fields.iter().any(|present| *present) && !broker_fields.iter().all(|present| *present)
2019 {
2020 return Err(DevelopmentError::InvalidInput(
2021 "Pi resident broker socket, token, and workspace must be configured together".into(),
2022 ));
2023 }
2024 if let Some(socket) = &options.broker_socket
2025 && (!socket.is_absolute() || socket == Path::new("/"))
2026 {
2027 return Err(DevelopmentError::InvalidInput(
2028 "Pi resident broker socket must be an explicit absolute path".into(),
2029 ));
2030 }
2031 for (description, value, limit) in [
2032 ("broker token", options.broker_token.as_deref(), 256),
2033 (
2034 "broker workspace",
2035 options.broker_workspace_id.as_deref(),
2036 128,
2037 ),
2038 ] {
2039 if let Some(value) = value
2040 && (value.is_empty() || value.len() > limit || value.chars().any(char::is_control))
2041 {
2042 return Err(DevelopmentError::InvalidInput(format!(
2043 "Pi {description} must contain 1..={limit} non-control bytes"
2044 )));
2045 }
2046 }
2047 if options.session_id.is_some() && options.fork.is_some() {
2048 return Err(DevelopmentError::InvalidInput(
2049 "Pi session ID and fork source are mutually exclusive".into(),
2050 ));
2051 }
2052 if (options.session_id.is_some()
2053 || options.fork.is_some()
2054 || options.session_dir.is_some()
2055 || options.name.is_some())
2056 && !options.persist_session
2057 {
2058 return Err(DevelopmentError::InvalidInput(
2059 "Pi session options require persistent session storage".into(),
2060 ));
2061 }
2062 for (description, value, limit) in [
2063 ("session ID", options.session_id.as_deref(), 256),
2064 ("fork source", options.fork.as_deref(), 4096),
2065 ("session name", options.name.as_deref(), 256),
2066 ("model", options.model.as_deref(), 512),
2067 ] {
2068 if let Some(value) = value
2069 && (value.is_empty()
2070 || value.len() > limit
2071 || value.chars().any(|character| character.is_control()))
2072 {
2073 return Err(DevelopmentError::InvalidInput(format!(
2074 "Pi {description} must contain 1..={limit} non-control bytes"
2075 )));
2076 }
2077 }
2078 if let Some(thinking) = options.thinking.as_deref()
2079 && !matches!(
2080 thinking,
2081 "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
2082 )
2083 {
2084 return Err(DevelopmentError::InvalidInput(
2085 "Pi thinking level must be off, minimal, low, medium, high, xhigh, or max".into(),
2086 ));
2087 }
2088 if let Some(directory) = &options.session_dir
2089 && (!directory.is_absolute() || directory == Path::new("/"))
2090 {
2091 return Err(DevelopmentError::InvalidInput(
2092 "Pi session directory must be an explicit absolute path".into(),
2093 ));
2094 }
2095 Ok(())
2096}
2097
2098fn env_enabled(name: &str) -> bool {
2099 std::env::var(name).is_ok_and(|value| value == "1" || value.eq_ignore_ascii_case("true"))
2100}
2101
2102#[derive(Debug, Clone, PartialEq, Eq)]
2103pub(crate) struct PiUiRequest {
2104 pub id: String,
2105 pub title: String,
2106 pub message: String,
2107}
2108
2109pub(crate) fn pi_ui_request(value: &Value) -> DevelopmentResult<Option<PiUiRequest>> {
2110 if value.get("type").and_then(Value::as_str) != Some("extension_ui_request") {
2111 return Ok(None);
2112 }
2113 let id = value
2114 .get("id")
2115 .and_then(Value::as_str)
2116 .filter(|id| !id.is_empty() && id.len() <= 128 && !id.chars().any(char::is_control))
2117 .ok_or_else(|| DevelopmentError::InvalidInput("invalid Pi UI request id".into()))?;
2118 let method = value.get("method").and_then(Value::as_str).unwrap_or("");
2119 if method != "confirm" {
2120 return Err(DevelopmentError::InvalidInput(format!(
2121 "unsupported Pi UI request method: {method}"
2122 )));
2123 }
2124 let bounded_field = |name: &str, limit: usize| -> DevelopmentResult<String> {
2125 let field = value.get(name).and_then(Value::as_str).unwrap_or("");
2126 if field.len() > limit || field.chars().any(|character| character == '\0') {
2127 return Err(DevelopmentError::InvalidInput(format!(
2128 "invalid Pi UI request {name}"
2129 )));
2130 }
2131 Ok(field.to_string())
2132 };
2133 Ok(Some(PiUiRequest {
2134 id: id.to_string(),
2135 title: bounded_field("title", 256)?,
2136 message: bounded_field("message", 2048)?,
2137 }))
2138}
2139
2140pub(crate) fn pi_response_matches(value: &Value, id: &str) -> bool {
2141 value.get("type").and_then(Value::as_str) == Some("response")
2142 && value.get("id").and_then(Value::as_str) == Some(id)
2143}
2144
2145pub(crate) fn pi_agent_settled(value: &Value) -> bool {
2146 value.get("type").and_then(Value::as_str) == Some("agent_settled")
2147}
2148
2149pub(crate) fn pi_event_visible(value: &Value) -> bool {
2150 if value.get("type").and_then(Value::as_str) == Some("message_end") {
2151 return value
2152 .get("message")
2153 .and_then(|message| message.get("role"))
2154 .and_then(Value::as_str)
2155 == Some("assistant");
2156 }
2157 matches!(
2158 value.get("type").and_then(Value::as_str),
2159 Some(
2160 "response"
2161 | "tool_execution_start"
2162 | "tool_execution_end"
2163 | "agent_settled"
2164 | "extension_error"
2165 | "extension_ui_request"
2166 )
2167 )
2168}
2169
2170pub fn pi_event_display(value: &Value) -> Option<String> {
2171 match value.get("type").and_then(Value::as_str)? {
2172 "message_end" => {
2173 let message = value.get("message")?;
2174 if message.get("role").and_then(Value::as_str) != Some("assistant") {
2175 return None;
2176 }
2177 let content = message.get("content")?;
2178 if let Some(text) = content.as_str() {
2179 return (!text.is_empty()).then(|| text.to_string());
2180 }
2181 let text = content
2182 .as_array()?
2183 .iter()
2184 .filter(|part| part.get("type").and_then(Value::as_str) == Some("text"))
2185 .filter_map(|part| part.get("text").and_then(Value::as_str))
2186 .collect::<Vec<_>>()
2187 .join("\n");
2188 (!text.is_empty()).then_some(text)
2189 }
2190 "tool_execution_start" => Some(format!(
2191 "Pi tool running: {}",
2192 value
2193 .get("toolName")
2194 .and_then(Value::as_str)
2195 .unwrap_or("unknown")
2196 )),
2197 "tool_execution_end" => Some(format!(
2198 "Pi tool {}: {}",
2199 value
2200 .get("toolName")
2201 .and_then(Value::as_str)
2202 .unwrap_or("unknown"),
2203 if value.get("isError").and_then(Value::as_bool) == Some(true) {
2204 "failed"
2205 } else {
2206 "completed"
2207 }
2208 )),
2209 "extension_error" => Some(format!(
2210 "Pi extension error: {}",
2211 value
2212 .get("error")
2213 .and_then(Value::as_str)
2214 .unwrap_or("unknown error")
2215 )),
2216 "response" => serde_json::to_string_pretty(value).ok(),
2217 "agent_settled" | "extension_ui_request" => None,
2218 _ => None,
2219 }
2220}
2221
2222impl Drop for PiHarness {
2223 fn drop(&mut self) {
2224 let _ = self.child.kill();
2225 let _ = self.child.wait();
2226 let _ = std::fs::remove_file(&self.extension_path);
2227 }
2228}
2229
2230fn prompt_evidence(text: &str) -> Value {
2231 let digest = Sha256::digest(text.as_bytes());
2232 serde_json::json!({
2233 "bytes": text.len(),
2234 "sha256": digest.iter().map(|byte| format!("{byte:02x}")).collect::<String>()
2235 })
2236}
2237
2238#[cfg(test)]
2239mod tests {
2240 use super::*;
2241 use std::fs;
2242
2243 #[test]
2244 fn pi_session_options_require_safe_persistent_configuration() {
2245 let directory = std::env::temp_dir().join("glass-pi-sessions");
2246 assert!(
2247 validate_pi_harness_options(&PiHarnessOptions {
2248 persist_session: true,
2249 session_id: Some("session-1".into()),
2250 session_dir: Some(directory),
2251 thinking: Some("high".into()),
2252 ..PiHarnessOptions::default()
2253 })
2254 .is_ok()
2255 );
2256 assert!(
2257 validate_pi_harness_options(&PiHarnessOptions {
2258 session_id: Some("session-1".into()),
2259 ..PiHarnessOptions::default()
2260 })
2261 .is_err()
2262 );
2263 assert!(
2264 validate_pi_harness_options(&PiHarnessOptions {
2265 persist_session: true,
2266 thinking: Some("unbounded".into()),
2267 ..PiHarnessOptions::default()
2268 })
2269 .is_err()
2270 );
2271 }
2272
2273 #[test]
2274 fn local_harness_proves_prompt_tool_result_and_steer_events() {
2275 let root = std::env::temp_dir().join(format!("glass-agent-{}", std::process::id()));
2276 let _ = fs::remove_dir_all(&root);
2277 fs::create_dir_all(&root).unwrap();
2278 fs::write(root.join("note.txt"), "hello agent").unwrap();
2279 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2280 let mut harness = LocalHarness::default();
2281 assert!(matches!(
2282 harness
2283 .handle(&mut workspace, HarnessRequest::Hello)
2284 .unwrap()[0],
2285 HarnessEvent::Hello { .. }
2286 ));
2287 let events = harness
2288 .handle(
2289 &mut workspace,
2290 HarnessRequest::Prompt {
2291 text: "read note.txt".into(),
2292 },
2293 )
2294 .unwrap();
2295 assert!(
2296 events
2297 .iter()
2298 .any(|event| matches!(event, HarnessEvent::ToolCall(_)))
2299 );
2300 assert!(
2301 events
2302 .iter()
2303 .any(|event| matches!(event, HarnessEvent::ToolResult { .. }))
2304 );
2305 assert!(matches!(
2306 harness
2307 .handle(
2308 &mut workspace,
2309 HarnessRequest::Steer {
2310 text: "stop".into()
2311 }
2312 )
2313 .unwrap()[0],
2314 HarnessEvent::State { .. }
2315 ));
2316 assert!(workspace.timeline().events().all(|event| {
2317 !event.payload.to_string().contains("read note.txt")
2318 && !event.payload.to_string().contains("stop")
2319 }));
2320 let _ = fs::remove_dir_all(root);
2321 }
2322
2323 #[test]
2324 fn pi_adapter_negotiates_real_rpc_state_when_pi_is_available() {
2325 if Command::new("pi").arg("--version").output().is_err() {
2326 return;
2327 }
2328 let mut harness = PiHarness::spawn(Path::new(".")).unwrap();
2329 let events = harness.request(HarnessRequest::Hello).unwrap();
2330 assert!(
2331 !events.iter().any(|event| {
2332 event.get("type").and_then(Value::as_str) == Some("extension_error")
2333 })
2334 );
2335 assert!(events.iter().any(|event| {
2336 event.get("type").and_then(Value::as_str) == Some("response")
2337 && event.get("command").and_then(Value::as_str) == Some("get_state")
2338 && event.get("success").and_then(Value::as_bool) == Some(true)
2339 }));
2340 }
2341
2342 #[test]
2343 fn pi_contract_is_glass_specific_approved_and_event_bounded() {
2344 let prompt = include_str!("../../assets/pi-glass-system.md");
2345 let tools = include_str!("../../assets/pi-glass-tools.ts");
2346 assert!(prompt.contains("embedded inside Glass Dev"));
2347 assert!(prompt.contains("Structured browser observation is the default"));
2348 assert!(prompt.contains("per-call approval"));
2349 for tool in [
2350 "glass_git_status",
2351 "glass_semantic_inspect",
2352 "glass_web_ir_inspect",
2353 "glass_web_ir_diff",
2354 "glass_web_ir_continuity",
2355 "glass_task_plan",
2356 "glass_runtime_inspect",
2357 "glass_capabilities",
2358 "glass_diagnostics_run",
2359 "glass_file_mkdir",
2360 "glass_file_rename",
2361 "glass_file_delete",
2362 "glass_test_run",
2363 "glass_process_start",
2364 "glass_process_stop",
2365 "\"read\"",
2366 "\"write\"",
2367 "\"edit\"",
2368 "\"bash\"",
2369 "\"grep\"",
2370 "\"find\"",
2371 "\"ls\"",
2372 ] {
2373 assert!(tools.contains(tool), "missing Pi tool {tool}");
2374 }
2375 assert!(tools.contains("ctx.ui.confirm"));
2376 assert!(tools.contains("GLASS_PI_YOLO"));
2377 assert!(tools.contains("mutating && !unrestricted"));
2378 assert!(tools.contains("--allow-mutation"));
2379 assert!(tools.contains("exact serialized call once"));
2380 assert!(tools.contains("register(\"glass_process_start\", \"glass.process.start\""));
2381 assert!(tools.contains("register(\"glass_process_stop\", \"glass.process.stop\""));
2382
2383 let response = serde_json::json!({
2384 "type": "response",
2385 "id": "glass-9",
2386 "command": "prompt",
2387 "success": true
2388 });
2389 assert!(pi_response_matches(&response, "glass-9"));
2390 assert!(pi_event_visible(&response));
2391 assert!(!pi_agent_settled(&response));
2392 assert!(!pi_event_visible(
2393 &serde_json::json!({"type":"message_update"})
2394 ));
2395 assert!(!pi_event_visible(&serde_json::json!({
2396 "type":"message_end",
2397 "message":{"role":"user","content":"private prompt"}
2398 })));
2399 assert!(!pi_agent_settled(&serde_json::json!({"type":"agent_end"})));
2400 assert!(pi_agent_settled(
2401 &serde_json::json!({"type":"agent_settled"})
2402 ));
2403 assert_eq!(
2404 pi_event_display(&serde_json::json!({
2405 "type":"message_end",
2406 "message":{"role":"assistant","content":[{"type":"text","text":"done"}]}
2407 })),
2408 Some("done".into())
2409 );
2410 }
2411
2412 #[test]
2413 fn pi_ui_requests_accept_only_bounded_confirm_dialogs() {
2414 let request = serde_json::json!({
2415 "type":"extension_ui_request",
2416 "id":"approval-7",
2417 "method":"confirm",
2418 "title":"Approve glass.file.patch?",
2419 "message":"File: src/main.rs"
2420 });
2421 assert_eq!(
2422 pi_ui_request(&request).unwrap(),
2423 Some(PiUiRequest {
2424 id: "approval-7".into(),
2425 title: "Approve glass.file.patch?".into(),
2426 message: "File: src/main.rs".into(),
2427 })
2428 );
2429 assert!(
2430 pi_ui_request(&serde_json::json!({
2431 "type":"extension_ui_request", "id":"x", "method":"input"
2432 }))
2433 .is_err()
2434 );
2435 assert!(
2436 pi_ui_request(&serde_json::json!({
2437 "type":"extension_ui_request", "id":"bad\nid", "method":"confirm"
2438 }))
2439 .is_err()
2440 );
2441 }
2442
2443 #[test]
2444 fn tool_registry_executes_attributed_file_patch_and_fails_closed_for_unattached_browser() {
2445 let root = std::env::temp_dir().join(format!("glass-tools-{}", std::process::id()));
2446 let _ = fs::remove_dir_all(&root);
2447 fs::create_dir_all(&root).unwrap();
2448 fs::write(root.join("note.txt"), "before\n").unwrap();
2449 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2450 let gateway = AgentToolGateway::default();
2451 let result = gateway
2452 .execute(
2453 &mut workspace,
2454 &ToolCall {
2455 id: "tool-1".into(),
2456 name: "glass.file.patch".into(),
2457 arguments: serde_json::json!({"path":"note.txt","search":"before","replace":"after"}),
2458 },
2459 &ToolAuthorization {
2460 actor: Actor::embedded(),
2461 allow_mutation: true,
2462 confirmed: true,
2463 },
2464 )
2465 .unwrap();
2466 assert_eq!(result["replacements"], 1);
2467 assert_eq!(
2468 fs::read_to_string(root.join("note.txt")).unwrap(),
2469 "after\n"
2470 );
2471 assert!(
2472 gateway
2473 .execute(
2474 &mut workspace,
2475 &ToolCall {
2476 id: "tool-2".into(),
2477 name: "glass.browser.observe".into(),
2478 arguments: serde_json::json!({}),
2479 },
2480 &ToolAuthorization::read_only(Actor::embedded()),
2481 )
2482 .is_err()
2483 );
2484 let _ = fs::remove_dir_all(root);
2485 }
2486
2487 #[test]
2488 fn tool_gateway_rejects_unconfirmed_mutation_and_unknown_arguments_without_audit_leaks() {
2489 let root = std::env::temp_dir().join(format!("glass-tool-policy-{}", std::process::id()));
2490 let _ = fs::remove_dir_all(&root);
2491 fs::create_dir_all(&root).unwrap();
2492 fs::write(root.join("note.txt"), "private-before\n").unwrap();
2493 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2494 let gateway = AgentToolGateway::default();
2495 let mutating = ToolCall {
2496 id: "denied".into(),
2497 name: "glass.file.patch".into(),
2498 arguments: serde_json::json!({
2499 "path":"note.txt",
2500 "search":"private-before",
2501 "replace":"private-after"
2502 }),
2503 };
2504 assert!(
2505 gateway
2506 .execute(
2507 &mut workspace,
2508 &mutating,
2509 &ToolAuthorization::read_only(Actor::embedded()),
2510 )
2511 .is_err()
2512 );
2513 assert_eq!(
2514 fs::read_to_string(root.join("note.txt")).unwrap(),
2515 "private-before\n"
2516 );
2517
2518 let invalid = ToolCall {
2519 id: "invalid".into(),
2520 name: "glass.file.list".into(),
2521 arguments: serde_json::json!({"unexpected":"private-value"}),
2522 };
2523 assert!(
2524 gateway
2525 .execute(
2526 &mut workspace,
2527 &invalid,
2528 &ToolAuthorization::read_only(Actor::embedded()),
2529 )
2530 .is_err()
2531 );
2532 let audit =
2533 serde_json::to_string(&workspace.timeline().events().collect::<Vec<_>>()).unwrap();
2534 assert!(!audit.contains("private-before"));
2535 assert!(!audit.contains("private-after"));
2536 assert!(!audit.contains("private-value"));
2537 let _ = fs::remove_dir_all(root);
2538 }
2539
2540 #[test]
2541 fn coding_gateway_writes_and_applies_atomic_multi_edits() {
2542 let root = std::env::temp_dir().join(format!("glass-coding-tools-{}", std::process::id()));
2543 let _ = fs::remove_dir_all(&root);
2544 fs::create_dir_all(&root).unwrap();
2545 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2546 let gateway = AgentToolGateway::default();
2547 let authority = ToolAuthorization {
2548 actor: Actor::external("pi"),
2549 allow_mutation: true,
2550 confirmed: true,
2551 };
2552 gateway
2553 .execute(
2554 &mut workspace,
2555 &ToolCall {
2556 id: "write-1".into(),
2557 name: "glass.file.write".into(),
2558 arguments: serde_json::json!({
2559 "path":"src/example.rs",
2560 "content":"fn alpha() {}\nfn beta() {}\n"
2561 }),
2562 },
2563 &authority,
2564 )
2565 .unwrap();
2566 let result = gateway
2567 .execute(
2568 &mut workspace,
2569 &ToolCall {
2570 id: "edit-1".into(),
2571 name: "glass.file.edit".into(),
2572 arguments: serde_json::json!({
2573 "path":"src/example.rs",
2574 "edits":[
2575 {"oldText":"alpha", "newText":"first"},
2576 {"oldText":"beta", "newText":"second"}
2577 ]
2578 }),
2579 },
2580 &authority,
2581 )
2582 .unwrap();
2583 assert_eq!(result["replacements"], 2);
2584 assert_eq!(
2585 fs::read_to_string(root.join("src/example.rs")).unwrap(),
2586 "fn first() {}\nfn second() {}\n"
2587 );
2588 let read = gateway
2589 .execute(
2590 &mut workspace,
2591 &ToolCall {
2592 id: "read-page".into(),
2593 name: "glass.file.read".into(),
2594 arguments: serde_json::json!({"path":"src/example.rs","offset":2,"limit":1}),
2595 },
2596 &ToolAuthorization::read_only(Actor::external("pi")),
2597 )
2598 .unwrap();
2599 assert_eq!(read["content"], "fn second() {}\n");
2600 assert_eq!(read["offset"], 2);
2601 assert!(
2602 read["sha256"]
2603 .as_str()
2604 .is_some_and(|value| value.len() == 64)
2605 );
2606
2607 {
2608 let command = "printf command-private-value";
2609 let command_result = gateway
2610 .execute(
2611 &mut workspace,
2612 &ToolCall {
2613 id: "command-1".into(),
2614 name: "glass.command.run".into(),
2615 arguments: serde_json::json!({
2616 "name":"pi-command-test", "command":command, "timeoutSeconds":5
2617 }),
2618 },
2619 &authority,
2620 )
2621 .unwrap();
2622 assert!(
2623 command_result["output"]
2624 .as_str()
2625 .is_some_and(|value| value.contains("command-private-value"))
2626 );
2627 assert!(
2628 workspace
2629 .timeline()
2630 .events()
2631 .all(|event| !event.payload.to_string().contains(command))
2632 );
2633 assert!(workspace.timeline().events().all(|event| !matches!(
2634 event.kind,
2635 DevelopmentEventKind::TestStarted | DevelopmentEventKind::TestCompleted
2636 )));
2637 }
2638 let _ = fs::remove_dir_all(root);
2639 }
2640
2641 #[test]
2642 fn coding_gateway_lists_finds_and_greps_with_bounded_standard_semantics() {
2643 let root = std::env::temp_dir().join(format!("glass-coding-search-{}", std::process::id()));
2644 let _ = fs::remove_dir_all(&root);
2645 fs::create_dir_all(root.join("src/nested")).unwrap();
2646 fs::write(root.join("src/lib.rs"), "alpha\nNeedle target\nomega\n").unwrap();
2647 fs::write(root.join("src/nested/mod.rs"), "needle second\n").unwrap();
2648 fs::write(root.join("README.md"), "Needle outside\n").unwrap();
2649 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2650 let gateway = AgentToolGateway::default();
2651 let authority = ToolAuthorization::read_only(Actor::external("pi"));
2652
2653 let listed = gateway
2654 .execute(
2655 &mut workspace,
2656 &ToolCall {
2657 id: "list-src".into(),
2658 name: "glass.file.list".into(),
2659 arguments: serde_json::json!({"path":"src","limit":2}),
2660 },
2661 &authority,
2662 )
2663 .unwrap();
2664 assert_eq!(listed["entries"].as_array().unwrap().len(), 2);
2665 assert_eq!(listed["truncated"], true);
2666 assert!(
2667 listed["entries"]
2668 .as_array()
2669 .unwrap()
2670 .iter()
2671 .all(|entry| entry["path"].as_str().unwrap().starts_with("src"))
2672 );
2673
2674 let found = gateway
2675 .execute(
2676 &mut workspace,
2677 &ToolCall {
2678 id: "find-rs".into(),
2679 name: "glass.file.find".into(),
2680 arguments: serde_json::json!({"pattern":"src/*.rs","limit":20}),
2681 },
2682 &authority,
2683 )
2684 .unwrap();
2685 assert_eq!(found["paths"].as_array().unwrap().len(), 2);
2686
2687 let grep = gateway
2688 .execute(
2689 &mut workspace,
2690 &ToolCall {
2691 id: "grep-needle".into(),
2692 name: "glass.file.grep".into(),
2693 arguments: serde_json::json!({
2694 "pattern":"needle", "path":"src", "glob":"*.rs",
2695 "ignoreCase":true, "context":1, "limit":10
2696 }),
2697 },
2698 &authority,
2699 )
2700 .unwrap();
2701 assert_eq!(grep["matches"].as_array().unwrap().len(), 2);
2702 assert_eq!(grep["literal"], true);
2703 assert_eq!(grep["matches"][0]["contextBefore"][0], "alpha");
2704 let _ = fs::remove_dir_all(root);
2705 }
2706
2707 #[test]
2708 fn tool_gateway_bounds_envelopes_and_reuses_its_descriptor_catalog() {
2709 let root = std::env::temp_dir().join(format!("glass-tool-envelope-{}", std::process::id()));
2710 let _ = fs::remove_dir_all(&root);
2711 fs::create_dir_all(&root).unwrap();
2712 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2713 let gateway = AgentToolGateway::default();
2714 let descriptor_storage = gateway.descriptors.as_ptr();
2715
2716 for (id, name) in [("", "glass.file.list"), ("valid", "bad name")] {
2717 let error = gateway
2718 .execute(
2719 &mut workspace,
2720 &ToolCall {
2721 id: id.into(),
2722 name: name.into(),
2723 arguments: serde_json::json!({}),
2724 },
2725 &ToolAuthorization::read_only(Actor::embedded()),
2726 )
2727 .unwrap_err();
2728 assert!(matches!(error, DevelopmentError::InvalidInput(_)));
2729 }
2730 let oversized_id = "x".repeat(MAX_TOOL_CALL_ID_BYTES + 1);
2731 assert!(
2732 gateway
2733 .execute(
2734 &mut workspace,
2735 &ToolCall {
2736 id: oversized_id,
2737 name: "glass.file.list".into(),
2738 arguments: serde_json::json!({}),
2739 },
2740 &ToolAuthorization::read_only(Actor::embedded()),
2741 )
2742 .is_err()
2743 );
2744 assert_eq!(descriptor_storage, gateway.descriptors.as_ptr());
2745 let _ = fs::remove_dir_all(root);
2746 }
2747
2748 #[test]
2749 fn subprocess_broker_reports_resident_process_tools_as_unavailable() {
2750 let gateway = AgentToolGateway::subprocess_broker();
2751 for name in [
2752 "glass.process.start",
2753 "glass.process.stop",
2754 "glass.process.logs",
2755 "glass.process.list",
2756 ] {
2757 let descriptor = gateway
2758 .descriptors()
2759 .into_iter()
2760 .find(|descriptor| descriptor.name == name)
2761 .unwrap();
2762 assert!(!descriptor.available);
2763 assert!(
2764 descriptor
2765 .unavailable_reason
2766 .as_deref()
2767 .is_some_and(|reason| reason.contains("resident Glass Dev"))
2768 );
2769 }
2770 let root = std::env::temp_dir().join(format!("glass-capabilities-{}", std::process::id()));
2771 let _ = fs::remove_dir_all(&root);
2772 fs::create_dir_all(&root).unwrap();
2773 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2774 let result = gateway
2775 .execute(
2776 &mut workspace,
2777 &ToolCall {
2778 id: "capabilities".into(),
2779 name: "glass.capabilities.inspect".into(),
2780 arguments: serde_json::json!({}),
2781 },
2782 &ToolAuthorization::read_only(Actor::external("pi")),
2783 )
2784 .unwrap();
2785 let processes = result
2786 .as_array()
2787 .unwrap()
2788 .iter()
2789 .filter(|descriptor| {
2790 descriptor["name"]
2791 .as_str()
2792 .is_some_and(|name| name.starts_with("glass.process."))
2793 })
2794 .collect::<Vec<_>>();
2795 assert_eq!(processes.len(), 4);
2796 assert!(
2797 processes
2798 .iter()
2799 .all(|descriptor| descriptor["available"] == false)
2800 );
2801 let _ = fs::remove_dir_all(root);
2802 }
2803
2804 #[test]
2805 fn attached_browser_enables_structured_observation_without_mutation_authority() {
2806 let root = std::env::temp_dir().join(format!("glass-tool-browser-{}", std::process::id()));
2807 let _ = fs::remove_dir_all(&root);
2808 fs::create_dir_all(&root).unwrap();
2809 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2810 let mut gateway = AgentToolGateway::default();
2811 gateway.set_browser_context(Some(BrowserAgentContext {
2812 connected: true,
2813 target_id: Some("page-1".into()),
2814 origin: Some("https://example.test".into()),
2815 title: "Example".into(),
2816 browser_revision: 42,
2817 semantic_summary: "button Continue".into(),
2818 workflow_state: "idle".into(),
2819 memory_scope: "profile/default".into(),
2820 }));
2821 let descriptor = gateway
2822 .descriptors()
2823 .into_iter()
2824 .find(|item| item.name == "glass.browser.observe")
2825 .unwrap();
2826 assert!(descriptor.available);
2827 let result = gateway
2828 .execute(
2829 &mut workspace,
2830 &ToolCall {
2831 id: "observe-1".into(),
2832 name: "glass.browser.observe".into(),
2833 arguments: serde_json::json!({}),
2834 },
2835 &ToolAuthorization::read_only(Actor::embedded()),
2836 )
2837 .unwrap();
2838 assert_eq!(result["browserRevision"], 42);
2839 assert_eq!(result["structured"], true);
2840 assert!(
2841 !gateway
2842 .descriptors()
2843 .into_iter()
2844 .find(|item| item.name == "glass.browser.act")
2845 .unwrap()
2846 .available
2847 );
2848 let _ = fs::remove_dir_all(root);
2849 }
2850
2851 #[test]
2852 fn tool_argument_evidence_is_streamed_once_and_stays_canonical() {
2853 let registry = ToolRegistry;
2854 let descriptor = registry
2855 .descriptors()
2856 .into_iter()
2857 .find(|descriptor| descriptor.name == "glass.file.read")
2858 .unwrap();
2859 let arguments = serde_json::json!({"path":"src/lib.rs"});
2860 let evidence = validate_tool_arguments(&descriptor, &arguments).unwrap();
2861 let canonical = serde_json::to_vec(&arguments).unwrap();
2862 assert_eq!(evidence.bytes, canonical.len());
2863 assert_eq!(evidence.sha256, digest_hex(&Sha256::digest(&canonical)));
2864
2865 let oversized = serde_json::json!({"path":"x".repeat(MAX_TOOL_ARGUMENT_BYTES)});
2866 let error = validate_tool_arguments(&descriptor, &oversized)
2867 .err()
2868 .expect("oversized arguments must fail");
2869 assert!(error.to_string().contains("tool arguments exceed"));
2870 }
2871
2872 #[test]
2873 fn semantic_context_resolves_explicit_references_without_dumping_file_contents() {
2874 let root = std::env::temp_dir().join(format!("glass-context-{}", std::process::id()));
2875 let _ = fs::remove_dir_all(&root);
2876 fs::create_dir_all(&root).unwrap();
2877 fs::write(root.join("secret.txt"), "do not inline this source").unwrap();
2878 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2879 let packet =
2880 resolve_context(&mut workspace, "Inspect @workspace and @file:secret.txt").unwrap();
2881 let serialized = serde_json::to_string(&packet).unwrap();
2882 assert!(!serialized.contains("do not inline this source"));
2883 assert_eq!(packet.references.len(), 2);
2884 }
2885}