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