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