Skip to main content

glass_dev/
tools.rs

1//! Governed tool routing into one resident development workspace.
2
3use crate::agents::AgentSpec;
4use crate::browser::BrowserStartConfig;
5use crate::debugger::{DebugAdapterConfig, SourceBreakpoint};
6use crate::kernels::KernelKind;
7use crate::workspace::DevelopmentWorkspace;
8use crate::{DevelopmentNode, DevelopmentNodeKind, ObservableEventInput};
9use glass_browser::browser::session::{
10    SemanticObservationLevel, WorkflowRecordingSession, record_semantic_events,
11};
12use glass_browser::development::{
13    AgentToolGateway, DevelopmentError, DevelopmentResult, HarnessRequest, ToolAuthorization,
14    ToolCall, ToolDescriptor,
15};
16use serde_json::Value;
17use std::path::PathBuf;
18use std::time::Duration;
19
20const RESULT_LIMIT: usize = 512 * 1024;
21
22#[derive(Debug, Clone)]
23pub struct DevelopmentToolContext {
24    pub authorization: ToolAuthorization,
25    pub expected_generation: u64,
26    pub expected_project_revision: u64,
27}
28
29/// Routes Glass Agent operations through authoritative resident services.
30#[derive(Debug, Clone)]
31pub struct DevelopmentToolRouter {
32    core: AgentToolGateway,
33    descriptors: Vec<ToolDescriptor>,
34}
35
36impl Default for DevelopmentToolRouter {
37    fn default() -> Self {
38        let core = AgentToolGateway::default();
39        let service = service_descriptors();
40        let mut descriptors = core
41            .descriptors()
42            .into_iter()
43            .filter(|descriptor| {
44                !service
45                    .iter()
46                    .any(|candidate| candidate.name == descriptor.name)
47            })
48            .collect::<Vec<_>>();
49        descriptors.extend(service);
50        Self { core, descriptors }
51    }
52}
53
54impl DevelopmentToolRouter {
55    pub fn with_customization(customization: &crate::Customization) -> Self {
56        let mut router = Self::default();
57        let custom = customization.descriptors();
58        router
59            .descriptors
60            .retain(|descriptor| !custom.iter().any(|item| item.name == descriptor.name));
61        router.descriptors.extend(custom);
62        router
63    }
64
65    pub fn descriptors(&self) -> Vec<ToolDescriptor> {
66        self.descriptors.clone()
67    }
68
69    pub fn execute(
70        &self,
71        workspace: &mut DevelopmentWorkspace,
72        call: &ToolCall,
73        context: &DevelopmentToolContext,
74    ) -> DevelopmentResult<Value> {
75        if workspace.generation() != context.expected_generation {
76            return Err(DevelopmentError::Conflict(format!(
77                "stale workspace generation {}; current generation is {}",
78                context.expected_generation,
79                workspace.generation()
80            )));
81        }
82        if workspace.project().revision() != context.expected_project_revision {
83            return Err(DevelopmentError::Conflict(format!(
84                "stale project revision {}; current revision is {}",
85                context.expected_project_revision,
86                workspace.project().revision()
87            )));
88        }
89        let descriptor = self
90            .descriptors
91            .iter()
92            .find(|descriptor| descriptor.name == call.name)
93            .ok_or_else(|| DevelopmentError::NotFound(format!("tool {}", call.name)))?;
94        if descriptor.mutating
95            && (!context.authorization.allow_mutation || !context.authorization.confirmed)
96        {
97            return Err(DevelopmentError::Conflict(format!(
98                "tool {} requires mutation authority and confirmation",
99                call.name
100            )));
101        }
102        let actor_id = context.authorization.actor.id.clone();
103        let project_revision = workspace.project().revision();
104        let resource = format!("tool:{}", call.id);
105        let argument_bytes = serde_json::to_vec(&call.arguments)?.len();
106        workspace.intelligence_mut().upsert_node(DevelopmentNode {
107            id: resource.clone(),
108            kind: DevelopmentNodeKind::ToolCall,
109            label: call.name.clone(),
110            revision: project_revision,
111            stale: false,
112            evidence: serde_json::json!({
113                "toolCallId":call.id,
114                "name":call.name,
115                "mutating":descriptor.mutating,
116                "argumentBytes":argument_bytes
117            }),
118        })?;
119        workspace.intelligence_mut().link(
120            "repository:root",
121            &resource,
122            "receivedToolCall",
123            project_revision,
124            &actor_id,
125            serde_json::json!({"name":call.name}),
126        )?;
127        workspace.intelligence_mut().record(ObservableEventInput {
128            actor: &actor_id,
129            subsystem: "tool",
130            kind: "called",
131            resource: Some(&resource),
132            workspace_revision: project_revision,
133            evidence: serde_json::json!({"name":call.name,"mutating":descriptor.mutating}),
134            rationale: None,
135        })?;
136        workspace.customization().run_hooks(
137            "tool.before",
138            &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id}),
139        )?;
140        let result = if service_descriptors()
141            .iter()
142            .any(|descriptor| descriptor.name == call.name)
143        {
144            self.execute_service(workspace, call, context)
145        } else if workspace.customization().custom_tool(&call.name).is_some() {
146            workspace
147                .customization()
148                .execute_tool(&call.name, &call.arguments)
149        } else if let Some(name) = call.name.strip_prefix("glass.command.") {
150            workspace.customization().execute_command(name)
151        } else {
152            self.core
153                .execute(workspace.project_mut(), call, &context.authorization)
154        };
155        match result {
156            Ok(result) => {
157                workspace.customization().run_hooks(
158                    "tool.after",
159                    &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id,"ok":true}),
160                )?;
161                let result_bytes = serde_json::to_vec(&result)?.len();
162                if result_bytes > RESULT_LIMIT {
163                    return Err(DevelopmentError::InvalidInput(format!(
164                        "tool result exceeds the {RESULT_LIMIT} byte limit"
165                    )));
166                }
167                let resulting_revision = workspace.project().revision();
168                workspace.intelligence_mut().record(ObservableEventInput {
169                    actor: &actor_id,
170                    subsystem: "tool",
171                    kind: "completed",
172                    resource: Some(&resource),
173                    workspace_revision: resulting_revision,
174                    evidence: serde_json::json!({"name":call.name,"resultBytes":result_bytes}),
175                    rationale: None,
176                })?;
177                Ok(result)
178            }
179            Err(error) => {
180                workspace.customization().run_hooks(
181                    "tool.after",
182                    &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id,"ok":false,"error":error.to_string()}),
183                )?;
184                let resulting_revision = workspace.project().revision();
185                workspace.intelligence_mut().record(ObservableEventInput {
186                    actor: &actor_id,
187                    subsystem: "tool",
188                    kind: "failed",
189                    resource: Some(&resource),
190                    workspace_revision: resulting_revision,
191                    evidence: serde_json::json!({"name":call.name,"error":error.to_string()}),
192                    rationale: None,
193                })?;
194                Err(error)
195            }
196        }
197    }
198
199    fn execute_service(
200        &self,
201        workspace: &mut DevelopmentWorkspace,
202        call: &ToolCall,
203        context: &DevelopmentToolContext,
204    ) -> DevelopmentResult<Value> {
205        let string = |name: &str| required_string(call, name);
206        let actor = normalized_actor_id(&context.authorization.actor.id);
207        match call.name.as_str() {
208            "glass.editor.open" => map_service(
209                workspace
210                    .project_mut()
211                    .open_buffer(string("path")?, context.authorization.actor.clone()),
212            ),
213            "glass.editor.selection" => {
214                let path = string("path")?;
215                workspace
216                    .project()
217                    .buffer(path)
218                    .cloned()
219                    .map(|buffer| {
220                        serde_json::json!({
221                            "path":buffer.path,
222                            "line":buffer.cursor_line,
223                            "column":buffer.cursor_column,
224                            "actor":buffer.actor,
225                            "dirty":buffer.dirty
226                        })
227                    })
228                    .ok_or_else(|| DevelopmentError::NotFound(format!("buffer {path}")))
229            }
230            "glass.editor.replace" => {
231                let matches = workspace.project_mut().replace_in_buffer(
232                    string("path")?,
233                    string("oldText")?,
234                    string("newText")?,
235                    context.authorization.actor.clone(),
236                )?;
237                Ok(serde_json::json!({"replacements":matches}))
238            }
239            "glass.editor.save" => {
240                map_service(workspace.project_mut().save_buffer(string("path")?))
241            }
242            "glass.editor.diff" => map_service(workspace.project_mut().diff()),
243            "glass.editor.buffers" => Ok(serde_json::to_value(
244                workspace.project().buffers().cloned().collect::<Vec<_>>(),
245            )?),
246            "glass.process.restart" => {
247                map_service(workspace.project_mut().processes().restart(string("name")?))
248            }
249            "glass.process.input" => {
250                workspace
251                    .project_mut()
252                    .processes()
253                    .send_input(string("name")?, string("input")?)?;
254                Ok(serde_json::json!({"sent":true}))
255            }
256            "glass.process.resize" => {
257                let cols = u16_value(call, "cols")?;
258                let rows = u16_value(call, "rows")?;
259                workspace
260                    .project_mut()
261                    .processes()
262                    .resize(string("name")?, cols, rows)?;
263                Ok(serde_json::json!({"resized":true,"cols":cols,"rows":rows}))
264            }
265            "glass.process.health" => {
266                let name = string("name")?;
267                let snapshot = workspace
268                    .project_mut()
269                    .processes()
270                    .list_checked()?
271                    .into_iter()
272                    .find(|snapshot| snapshot.name == name)
273                    .ok_or_else(|| DevelopmentError::NotFound(format!("process {name}")))?;
274                Ok(serde_json::json!({
275                    "name":snapshot.name,
276                    "pid":snapshot.pid,
277                    "state":snapshot.state,
278                    "health":snapshot.health,
279                    "detectedUrls":snapshot.detected_urls
280                }))
281            }
282            "glass.process.ports" => {
283                let snapshots = workspace.project_mut().processes().list_checked()?;
284                Ok(serde_json::json!({
285                    "processes":snapshots.into_iter().map(|snapshot| serde_json::json!({
286                        "name":snapshot.name,
287                        "pid":snapshot.pid,
288                        "urls":snapshot.detected_urls
289                    })).collect::<Vec<_>>()
290                }))
291            }
292            "glass.browser.start" => {
293                let config: BrowserStartConfig = serde_json::from_value(call.arguments.clone())?;
294                workspace.browser().start(config)
295            }
296            "glass.browser.stop" => workspace.browser().stop(),
297            "glass.browser.attach" => {
298                let mut config: BrowserStartConfig = serde_json::from_value(call.arguments.clone())?;
299                config.attach = true;
300                workspace.browser().start(config)
301            }
302            "glass.browser.reconnect" => workspace.browser().reconnect(),
303            "glass.browser.state" => workspace.browser().state(),
304            "glass.browser.observe" => workspace.browser().observe(),
305            "glass.browser.snapshot" => workspace.browser().snapshot(),
306            "glass.browser.semantic" => workspace.browser().semantic(match optional_string(call, "level").unwrap_or("structured") {
307                "summary" => SemanticObservationLevel::Summary,
308                "interactive" => SemanticObservationLevel::Interactive,
309                "structured" => SemanticObservationLevel::Structured,
310                "detailed" => SemanticObservationLevel::Detailed,
311                "raw" => SemanticObservationLevel::Raw,
312                _ => return Err(DevelopmentError::InvalidInput("browser semantic level must be summary, interactive, structured, detailed, or raw".into())),
313            }),
314            "glass.browser.diff" => workspace.browser().diff(),
315            "glass.browser.targets" => workspace.browser().targets(),
316            "glass.browser.target.select" => workspace
317                .browser()
318                .select_target(string("targetId")?.into()),
319            "glass.browser.navigate" => workspace.browser().navigate(
320                string("url")?.into(),
321                unsigned(call, "browserRevision", 0)?,
322                timeout(call, 180)?.unwrap_or(Duration::from_secs(30)),
323            ),
324            "glass.browser.act" => {
325                let revision = unsigned(call, "browserRevision", 0)?;
326                match string("action")? {
327                    "click" => workspace
328                        .browser()
329                        .click(string("target")?.into(), revision),
330                    "type" => workspace.browser().type_text(
331                        string("text")?.into(),
332                        optional_string(call, "target").map(str::to_string),
333                        revision,
334                    ),
335                    "scroll" => workspace.browser().scroll(
336                        number(call, "dx", 0.0)?,
337                        number(call, "dy", 0.0)?,
338                        revision,
339                    ),
340                    action => Err(DevelopmentError::InvalidInput(format!(
341                        "unsupported browser action {action}; expected click, type, or scroll"
342                    ))),
343                }
344            }
345            "glass.browser.screenshot" => workspace.browser().screenshot(),
346            "glass.workflow.list" => workspace.browser().list_workflows(),
347            "glass.workflow.run" => workspace.browser().run_workflow(
348                required_value(call, "definition")?.clone(),
349                value_map(call, "inputs")?,
350            ),
351            "glass.workflow.pause" => workspace.browser().pause_workflow(),
352            "glass.workflow.resume" => workspace.browser().resume_workflow(
353                required_value(call, "definition")?.clone(),
354                value_map(call, "inputs")?,
355                required_value(call, "checkpoint")?.clone(),
356            ),
357            "glass.workflow.cancel" => workspace.browser().cancel_workflow(),
358            "glass.workflow.verify" => workspace.browser().verify_workflow(),
359            "glass.workflow.record" => {
360                let session: WorkflowRecordingSession = serde_json::from_value(
361                    required_value(call, "session")?.clone(),
362                )?;
363                Ok(serde_json::to_value(record_semantic_events(session).map_err(|error| {
364                    DevelopmentError::InvalidInput(error.to_string())
365                })?)?)
366            }
367            "glass.memory.retrieve" => {
368                if let Some(record_id) = optional_string(call, "recordId") {
369                    Ok(serde_json::to_value(
370                        workspace
371                            .knowledge()
372                            .get(record_id)
373                            .ok_or_else(|| DevelopmentError::NotFound(format!("memory record {record_id}")))?,
374                    )?)
375                } else {
376                    Ok(serde_json::json!({
377                        "records":workspace.knowledge().records(),
378                        "stats":workspace.knowledge().stats().map_err(|error| DevelopmentError::Process(error.to_string()))?
379                    }))
380                }
381            }
382            "glass.memory.explain" => {
383                let record_id = string("recordId")?;
384                let record = workspace
385                    .knowledge()
386                    .get(record_id)
387                    .ok_or_else(|| DevelopmentError::NotFound(format!("memory record {record_id}")))?;
388                Ok(serde_json::json!({
389                    "record":record,
390                    "advisory":true,
391                    "authority":"fresh browser evidence remains authoritative"
392                }))
393            }
394            "glass.memory.forget" => {
395                let record_id = string("recordId")?;
396                let change = workspace
397                    .knowledge_mut()
398                    .remove(record_id)
399                    .map_err(|error| DevelopmentError::Process(error.to_string()))?;
400                Ok(serde_json::to_value(change)?)
401            }
402            "glass.semantic.inspect" => workspace
403                .browser()
404                .semantic(SemanticObservationLevel::Structured),
405            "glass.semantic.diff" => workspace.browser().diff(),
406            "glass.semantic.links" => Ok(serde_json::json!({
407                "nodes":workspace.intelligence().nodes().collect::<Vec<_>>(),
408                "edges":workspace.intelligence().edges().collect::<Vec<_>>()
409            })),
410            "glass.git.status" => git_value(workspace.git(), |git| git.status()),
411            "glass.git.diff" => git_value(workspace.git(), |git| {
412                git.diff(
413                    boolean(call, "staged", false),
414                    optional_string(call, "path"),
415                )
416            }),
417            "glass.git.stage" => {
418                let paths = string_array(call, "paths")?;
419                git_mutation(workspace.git(), |git| git.stage(&paths))?;
420                Ok(serde_json::json!({"staged":paths}))
421            }
422            "glass.git.unstage" => {
423                let paths = string_array(call, "paths")?;
424                git_mutation(workspace.git(), |git| git.unstage(&paths))?;
425                Ok(serde_json::json!({"unstaged":paths}))
426            }
427            "glass.git.commit" => {
428                let message = string("message")?;
429                git_value(workspace.git(), |git| git.commit(message))
430            }
431            "glass.git.branches" => git_value(workspace.git(), |git| git.branches()),
432            "glass.git.branch.create" => {
433                let name = string("name")?;
434                let start_point = optional_string(call, "startPoint");
435                git_mutation(workspace.git(), |git| git.create_branch(name, start_point))?;
436                Ok(serde_json::json!({"created":name}))
437            }
438            "glass.git.branch.switch" => {
439                let name = string("name")?;
440                let create = boolean(call, "create", false);
441                git_mutation(workspace.git(), |git| git.switch_branch(name, create))?;
442                Ok(serde_json::json!({"current":name}))
443            }
444            "glass.git.blame" => {
445                let path = string("path")?;
446                let start = unsigned(call, "startLine", 1)?;
447                let end = unsigned(call, "endLine", 1)?;
448                git_value(workspace.git(), |git| git.blame(path, start, end))
449            }
450            "glass.git.conflicts" => git_value(workspace.git(), |git| git.conflicts()),
451            "glass.git.stash.list" => git_value(workspace.git(), |git| git.stash_list()),
452            "glass.git.stash.push" => {
453                let message = string("message")?;
454                let include_untracked = boolean(call, "includeUntracked", false);
455                git_mutation(workspace.git(), |git| {
456                    git.stash_push(message, include_untracked)
457                })?;
458                Ok(serde_json::json!({"stashed":true}))
459            }
460            "glass.git.stash.pop" => {
461                let reference = string("reference")?;
462                git_mutation(workspace.git(), |git| git.stash_pop(reference))?;
463                Ok(serde_json::json!({"restored":reference}))
464            }
465            "glass.git.worktree.list" => git_value(workspace.git(), |git| git.worktrees()),
466            "glass.git.worktree.create" => {
467                let path = PathBuf::from(string("path")?);
468                let branch = string("branch")?;
469                let create_branch = boolean(call, "createBranch", true);
470                git_mutation(workspace.git(), |git| {
471                    git.create_worktree(&path, branch, create_branch)
472                })?;
473                Ok(serde_json::json!({"path":path,"created":true}))
474            }
475            "glass.git.worktree.remove" => {
476                let path = PathBuf::from(string("path")?);
477                git_mutation(workspace.git(), |git| {
478                    git.remove_worktree(&path, boolean(call, "force", false))
479                })?;
480                Ok(serde_json::json!({"path":path,"removed":true}))
481            }
482            "glass.test.discover" => Ok(serde_json::to_value(
483                workspace.tests().suites().collect::<Vec<_>>(),
484            )?),
485            "glass.test.run" => {
486                let revision = workspace.project().revision();
487                map_service(workspace.tests_mut().start(
488                    string("runId")?,
489                    string("suiteId")?,
490                    &actor,
491                    revision,
492                    timeout(call, 3_600)?,
493                ))
494            }
495            "glass.test.run-affected" => {
496                let paths = string_array(call, "changedPaths")?;
497                let suite_ids = workspace
498                    .tests()
499                    .affected_suites(paths.iter().map(String::as_str))
500                    .into_iter()
501                    .map(|suite| suite.id.clone())
502                    .collect::<Vec<_>>();
503                let revision = workspace.project().revision();
504                let prefix = optional_string(call, "runPrefix").unwrap_or("affected");
505                let mut runs = Vec::new();
506                for (index, suite_id) in suite_ids.into_iter().enumerate() {
507                    runs.push(map_service(workspace.tests_mut().start(
508                        &format!("{prefix}-{index}"),
509                        &suite_id,
510                        &actor,
511                        revision,
512                        timeout(call, 3_600)?,
513                    ))?);
514                }
515                Ok(serde_json::to_value(runs)?)
516            }
517            "glass.test.cancel" => {
518                map_service(workspace.tests_mut().cancel(string("runId")?))?;
519                Ok(serde_json::json!({"cancelled":string("runId")?}))
520            }
521            "glass.test.results" => {
522                let finished = map_service(workspace.tests_mut().poll())?;
523                Ok(serde_json::json!({
524                    "finished":finished,
525                    "running":workspace.tests().running().collect::<Vec<_>>(),
526                    "results":workspace.tests().results().collect::<Vec<_>>()
527                }))
528            }
529            "glass.test.watch" => {
530                let revision = workspace.project().revision();
531                map_service(workspace.tests_mut().watch(string("suiteId")?, revision))?;
532                Ok(serde_json::json!({"watching":string("suiteId")?}))
533            }
534            "glass.eval.start" => {
535                let kind = parse_kernel_kind(string("kind")?)?;
536                map_service(workspace.kernels_mut().start(string("name")?, kind, &actor))?;
537                Ok(serde_json::json!({"started":string("name")?,"kind":kind}))
538            }
539            "glass.eval.execute" => {
540                let revision = workspace.project().revision();
541                map_service(workspace.kernels_mut().execute(
542                    string("name")?,
543                    string("code")?,
544                    &actor,
545                    revision,
546                    timeout(call, 600)?,
547                ))
548            }
549            "glass.eval.list" => Ok(serde_json::to_value(
550                workspace.kernels().snapshots().collect::<Vec<_>>(),
551            )?),
552            "glass.eval.reset" => {
553                map_service(workspace.kernels_mut().reset(string("name")?, &actor))?;
554                Ok(serde_json::json!({"reset":string("name")?}))
555            }
556            "glass.eval.stop" => map_service(workspace.kernels_mut().stop(string("name")?)),
557            "glass.lsp.start" => {
558                let server = string("server")?;
559                let configured = workspace.customization().config().lsp.get(server).cloned();
560                let config = match (optional_string(call, "command"), configured) {
561                    (Some(command), _) => crate::lsp::LanguageServerConfig {
562                        command: command.to_string(),
563                        arguments: string_array_or_empty(call, "arguments")?,
564                    },
565                    (None, Some(config)) => crate::lsp::LanguageServerConfig {
566                        command: config.command,
567                        arguments: config.args,
568                    },
569                    (None, None) => return Err(DevelopmentError::InvalidInput(
570                        "lsp start requires command or a matching glass.toml lsp entry".into(),
571                    )),
572                };
573                map_service(workspace.language().start(server, &config))?;
574                Ok(serde_json::json!({"started":server}))
575            }
576            "glass.lsp.stop" => {
577                map_service(workspace.language().stop(string("server")?))?;
578                Ok(serde_json::json!({"stopped":string("server")?}))
579            }
580            "glass.lsp.list" => Ok(serde_json::json!({
581                "servers":workspace.language().names().collect::<Vec<_>>()
582            })),
583            "glass.lsp.events" => Ok(serde_json::to_value(
584                workspace.language().events(unsigned(call, "since", 0)?),
585            )?),
586            "glass.lsp.raw" => map_service(workspace.language().raw_request(
587                string("server")?,
588                &actor,
589                string("method")?,
590                call.arguments
591                    .get("params")
592                    .cloned()
593                    .unwrap_or_else(|| serde_json::json!({})),
594                timeout(call, 60)?.unwrap_or(Duration::from_secs(10)),
595            )),
596            "glass.lsp.diagnostics" => map_service(workspace.language().diagnostics(
597                string("server")?,
598                &actor,
599                string("path")?,
600            )),
601            "glass.lsp.hover" => map_service(workspace.language().hover(
602                string("server")?,
603                &actor,
604                string("path")?,
605                unsigned(call, "line", 1)? as u32,
606                unsigned(call, "character", 1)? as u32,
607            )),
608            "glass.lsp.completion" => map_service(workspace.language().completion(
609                string("server")?,
610                &actor,
611                string("path")?,
612                unsigned(call, "line", 1)? as u32,
613                unsigned(call, "character", 1)? as u32,
614            )),
615            "glass.lsp.definition" => map_service(workspace.language().definition(
616                string("server")?,
617                &actor,
618                string("path")?,
619                u32_value(call, "line")?,
620                u32_value(call, "character")?,
621            )),
622            "glass.lsp.declaration" => map_service(workspace.language().declaration(
623                string("server")?,
624                &actor,
625                string("path")?,
626                u32_value(call, "line")?,
627                u32_value(call, "character")?,
628            )),
629            "glass.lsp.implementation" => map_service(workspace.language().implementation(
630                string("server")?,
631                &actor,
632                string("path")?,
633                u32_value(call, "line")?,
634                u32_value(call, "character")?,
635            )),
636            "glass.lsp.references" => map_service(workspace.language().references(
637                string("server")?,
638                &actor,
639                string("path")?,
640                u32_value(call, "line")?,
641                u32_value(call, "character")?,
642            )),
643            "glass.lsp.document_symbols" => map_service(workspace.language().document_symbols(
644                string("server")?,
645                &actor,
646                string("path")?,
647            )),
648            "glass.lsp.workspace_symbols" => map_service(workspace.language().workspace_symbols(
649                string("server")?,
650                &actor,
651                string("query")?,
652            )),
653            "glass.lsp.signature_help" => map_service(workspace.language().signature_help(
654                string("server")?,
655                &actor,
656                string("path")?,
657                u32_value(call, "line")?,
658                u32_value(call, "character")?,
659            )),
660            "glass.lsp.code_actions" => map_service(workspace.language().code_actions(
661                string("server")?,
662                &actor,
663                string("path")?,
664                position(call, "start")?,
665                position(call, "end")?,
666                value_array_or_empty(call, "diagnostics")?,
667            )),
668            "glass.lsp.formatting" => map_service(workspace.language().formatting(
669                string("server")?,
670                &actor,
671                string("path")?,
672            )),
673            "glass.lsp.range_formatting" => map_service(workspace.language().range_formatting(
674                string("server")?,
675                &actor,
676                string("path")?,
677                position(call, "start")?,
678                position(call, "end")?,
679            )),
680            "glass.lsp.semantic_tokens" => map_service(workspace.language().semantic_tokens(
681                string("server")?,
682                &actor,
683                string("path")?,
684            )),
685            "glass.lsp.rename" => map_service(workspace.language().rename(
686                string("server")?,
687                &actor,
688                string("path")?,
689                u32_value(call, "line")?,
690                u32_value(call, "character")?,
691                string("newName")?,
692            )),
693            "glass.debug.start" => {
694                let session = string("session")?;
695                let configured = workspace.customization().config().dap.get(session).cloned();
696                let config = match (optional_string(call, "command"), configured) {
697                    (Some(command), _) => DebugAdapterConfig::new(
698                        command,
699                        string_array_or_empty(call, "arguments")?,
700                    ),
701                    (None, Some(config)) => DebugAdapterConfig::new(config.command, config.args),
702                    (None, None) => return Err(DevelopmentError::InvalidInput(
703                        "debug start requires command or a matching glass.toml dap entry".into(),
704                    )),
705                };
706                map_debug(workspace.start_debugger(
707                    session,
708                    &config,
709                    Duration::from_secs(unsigned(call, "timeoutSeconds", 30)?),
710                ))?;
711                Ok(serde_json::json!({"started":session}))
712            }
713            "glass.debug.launch" => map_debug(
714                debugger(workspace, string("session")?)?.launch(
715                    call.arguments
716                        .get("configuration")
717                        .cloned()
718                        .unwrap_or(Value::Null),
719                ),
720            ),
721            "glass.debug.attach" => map_debug(
722                debugger(workspace, string("session")?)?.attach(
723                    call.arguments
724                        .get("configuration")
725                        .cloned()
726                        .unwrap_or(Value::Null),
727                ),
728            ),
729            "glass.debug.configuration_done" => {
730                map_debug(debugger(workspace, string("session")?)?.configuration_done())
731            }
732            "glass.debug.restart" => map_debug(
733                debugger(workspace, string("session")?)?.restart(
734                    call.arguments
735                        .get("configuration")
736                        .cloned()
737                        .unwrap_or_else(|| serde_json::json!({})),
738                ),
739            ),
740            "glass.debug.breakpoint.set" => {
741                let lines = unsigned_array(call, "lines")?;
742                let breakpoints = lines
743                    .iter()
744                    .copied()
745                    .map(SourceBreakpoint::line)
746                    .collect::<Vec<_>>();
747                map_debug(
748                    debugger(workspace, string("session")?)?
749                        .set_source_breakpoints(&PathBuf::from(string("path")?), &breakpoints),
750                )
751            }
752            "glass.debug.breakpoint.remove" => map_debug(
753                debugger(workspace, string("session")?)?
754                    .set_source_breakpoints(&PathBuf::from(string("path")?), &[]),
755            ),
756            "glass.debug.exception.set" => map_debug(
757                debugger(workspace, string("session")?)?
758                    .set_exception_breakpoints(&string_array_or_empty(call, "filters")?),
759            ),
760            "glass.debug.continue" => map_debug(
761                debugger(workspace, string("session")?)?
762                    .continue_thread(integer(call, "threadId")?),
763            ),
764            "glass.debug.pause" => map_debug(
765                debugger(workspace, string("session")?)?.pause(integer(call, "threadId")?),
766            ),
767            "glass.debug.step" => {
768                let debugger = debugger(workspace, string("session")?)?;
769                let thread = integer(call, "threadId")?;
770                match string("kind")? {
771                    "over" => map_debug(debugger.next(thread)),
772                    "in" => map_debug(debugger.step_in(thread)),
773                    "out" => map_debug(debugger.step_out(thread)),
774                    _ => Err(DevelopmentError::InvalidInput(
775                        "debug step kind must be over, in, or out".into(),
776                    )),
777                }
778            }
779            "glass.debug.threads" => map_debug(debugger(workspace, string("session")?)?.threads()),
780            "glass.debug.stack" => map_debug(
781                debugger(workspace, string("session")?)?.stack_trace(integer(call, "threadId")?),
782            ),
783            "glass.debug.scopes" => map_debug(
784                debugger(workspace, string("session")?)?.scopes(integer(call, "frameId")?),
785            ),
786            "glass.debug.variables" => map_debug(
787                debugger(workspace, string("session")?)?
788                    .variables(integer(call, "variablesReference")?),
789            ),
790            "glass.debug.evaluate" => map_debug(debugger(workspace, string("session")?)?.evaluate(
791                string("expression")?,
792                call.arguments.get("frameId").and_then(Value::as_i64),
793                optional_string(call, "context").unwrap_or("repl"),
794            )),
795            "glass.debug.events" => {
796                map_debug(debugger(workspace, string("session")?)?.poll_events())
797            }
798            "glass.debug.disconnect" => map_debug(
799                debugger(workspace, string("session")?)?
800                    .disconnect(boolean(call, "terminateDebuggee", false)),
801            ),
802            "glass.debug.terminate" => map_debug(
803                debugger(workspace, string("session")?)?
804                    .terminate(boolean(call, "restart", false)),
805            ),
806            "glass.debug.stop" => {
807                map_debug(workspace.stop_debugger(string("session")?))?;
808                Ok(serde_json::json!({"stopped":string("session")?}))
809            }
810            "glass.agent.list" => map_service(workspace.agents().list()),
811            "glass.agent.spawn" => {
812                let spec: AgentSpec =
813                    serde_json::from_value(call.arguments.get("spec").cloned().ok_or_else(
814                        || DevelopmentError::InvalidInput("agent spawn requires spec".into()),
815                    )?)?;
816                map_service(workspace.agents().create(spec))
817            }
818            "glass.agent.prompt" => {
819                let id = agent_id(workspace, string("agentId")?)?;
820                map_service(workspace.agents().prompt(&id, string("text")?))?;
821                Ok(serde_json::json!({"queued":true}))
822            }
823            "glass.agent.steer" => {
824                let id = agent_id(workspace, string("agentId")?)?;
825                map_service(workspace.agents().steer(&id, string("text")?))?;
826                Ok(serde_json::json!({"queued":true}))
827            }
828            "glass.agent.follow-up" => {
829                let id = agent_id(workspace, string("agentId")?)?;
830                map_service(workspace.agents().follow_up(&id, string("text")?))?;
831                Ok(serde_json::json!({"queued":true}))
832            }
833            "glass.agent.abort" => {
834                let id = agent_id(workspace, string("agentId")?)?;
835                map_service(workspace.agents().cancel(&id))?;
836                Ok(serde_json::json!({"cancelled":true}))
837            }
838            "glass.agent.compact" => {
839                let id = agent_id(workspace, string("agentId")?)?;
840                map_service(workspace.agents().request(
841                    &id,
842                    HarnessRequest::Compact {
843                        instructions: optional_string(call, "instructions").map(str::to_string),
844                    },
845                ))?;
846                Ok(serde_json::json!({"queued":true}))
847            }
848            "glass.agent.model" => {
849                let id = agent_id(workspace, string("agentId")?)?;
850                map_service(workspace.agents().request(
851                    &id,
852                    HarnessRequest::SetModel {
853                        provider: string("provider")?.into(),
854                        model_id: string("modelId")?.into(),
855                    },
856                ))?;
857                Ok(serde_json::json!({"queued":true}))
858            }
859            "glass.agent.thinking" => {
860                let id = agent_id(workspace, string("agentId")?)?;
861                map_service(workspace.agents().request(
862                    &id,
863                    HarnessRequest::SetThinking {
864                        level: string("level")?.into(),
865                    },
866                ))?;
867                Ok(serde_json::json!({"queued":true}))
868            }
869            "glass.agent.new-session" => agent_request(workspace, call, HarnessRequest::NewSession),
870            "glass.agent.clone-session" => {
871                agent_request(workspace, call, HarnessRequest::CloneSession)
872            }
873            "glass.agent.fork" => agent_request(
874                workspace,
875                call,
876                HarnessRequest::Fork {
877                    entry_id: string("entryId")?.into(),
878                },
879            ),
880            "glass.agent.switch-session" => agent_request(
881                workspace,
882                call,
883                HarnessRequest::SwitchSession {
884                    path: string("path")?.into(),
885                },
886            ),
887            "glass.agent.messages" => agent_request(workspace, call, HarnessRequest::Messages),
888            "glass.agent.entries" => agent_request(
889                workspace,
890                call,
891                HarnessRequest::Entries {
892                    since: optional_string(call, "since").map(str::to_string),
893                },
894            ),
895            "glass.agent.stats" => agent_request(workspace, call, HarnessRequest::SessionStats),
896            "glass.agent.name" => agent_request(
897                workspace,
898                call,
899                HarnessRequest::SetSessionName {
900                    name: string("name")?.into(),
901                },
902            ),
903            "glass.graph.query" => Ok(serde_json::to_value(
904                workspace.intelligence().node(string("id")?),
905            )?),
906            "glass.graph.path" | "glass.graph.explain" => Ok(serde_json::to_value(
907                workspace
908                    .intelligence()
909                    .path(string("from")?, string("to")?)?,
910            )?),
911            "glass.replay.list" | "glass.replay.inspect" => {
912                Ok(serde_json::to_value(workspace.intelligence().replay(
913                    unsigned(call, "since", 0)?,
914                    usize::try_from(unsigned(call, "limit", 128)?).unwrap_or(4096),
915                )?)?)
916            }
917            "glass.replay.diff" => Ok(serde_json::to_value(
918                workspace
919                    .intelligence()
920                    .replay_diff(unsigned(call, "from", 0)?, unsigned(call, "to", 1)?)?,
921            )?),
922            _ => Err(DevelopmentError::NotFound(format!("tool {}", call.name))),
923        }
924    }
925}
926
927fn service_descriptors() -> Vec<ToolDescriptor> {
928    const READ: &[&str] = &[
929        "glass.git.status",
930        "glass.git.diff",
931        "glass.git.branches",
932        "glass.git.blame",
933        "glass.git.conflicts",
934        "glass.git.stash.list",
935        "glass.git.worktree.list",
936        "glass.test.discover",
937        "glass.test.results",
938        "glass.eval.list",
939        "glass.lsp.diagnostics",
940        "glass.lsp.list",
941        "glass.lsp.events",
942        "glass.lsp.raw",
943        "glass.lsp.hover",
944        "glass.lsp.completion",
945        "glass.lsp.definition",
946        "glass.lsp.declaration",
947        "glass.lsp.implementation",
948        "glass.lsp.references",
949        "glass.lsp.document_symbols",
950        "glass.lsp.workspace_symbols",
951        "glass.lsp.signature_help",
952        "glass.lsp.code_actions",
953        "glass.lsp.formatting",
954        "glass.lsp.range_formatting",
955        "glass.lsp.semantic_tokens",
956        "glass.lsp.rename",
957        "glass.debug.stack",
958        "glass.debug.threads",
959        "glass.debug.scopes",
960        "glass.debug.variables",
961        "glass.debug.evaluate",
962        "glass.debug.events",
963        "glass.agent.list",
964        "glass.agent.messages",
965        "glass.agent.entries",
966        "glass.agent.stats",
967        "glass.graph.query",
968        "glass.graph.path",
969        "glass.graph.explain",
970        "glass.replay.list",
971        "glass.replay.inspect",
972        "glass.replay.diff",
973        "glass.editor.selection",
974        "glass.editor.diff",
975        "glass.editor.buffers",
976        "glass.process.health",
977        "glass.process.ports",
978        "glass.browser.state",
979        "glass.browser.observe",
980        "glass.browser.snapshot",
981        "glass.browser.semantic",
982        "glass.browser.diff",
983        "glass.browser.targets",
984        "glass.browser.screenshot",
985        "glass.workflow.list",
986        "glass.workflow.verify",
987        "glass.workflow.record",
988        "glass.memory.retrieve",
989        "glass.memory.explain",
990        "glass.semantic.inspect",
991        "glass.semantic.diff",
992        "glass.semantic.links",
993    ];
994    const MUTATE: &[&str] = &[
995        "glass.git.stage",
996        "glass.git.unstage",
997        "glass.git.commit",
998        "glass.git.branch.create",
999        "glass.git.branch.switch",
1000        "glass.git.stash.push",
1001        "glass.git.stash.pop",
1002        "glass.git.worktree.create",
1003        "glass.git.worktree.remove",
1004        "glass.test.run",
1005        "glass.test.run-affected",
1006        "glass.test.cancel",
1007        "glass.test.watch",
1008        "glass.eval.start",
1009        "glass.eval.execute",
1010        "glass.eval.reset",
1011        "glass.eval.stop",
1012        "glass.debug.start",
1013        "glass.lsp.start",
1014        "glass.lsp.stop",
1015        "glass.debug.launch",
1016        "glass.debug.attach",
1017        "glass.debug.configuration_done",
1018        "glass.debug.restart",
1019        "glass.debug.breakpoint.set",
1020        "glass.debug.breakpoint.remove",
1021        "glass.debug.exception.set",
1022        "glass.debug.continue",
1023        "glass.debug.pause",
1024        "glass.debug.step",
1025        "glass.debug.disconnect",
1026        "glass.debug.terminate",
1027        "glass.debug.stop",
1028        "glass.agent.spawn",
1029        "glass.agent.prompt",
1030        "glass.agent.steer",
1031        "glass.agent.follow-up",
1032        "glass.agent.abort",
1033        "glass.agent.compact",
1034        "glass.agent.model",
1035        "glass.agent.thinking",
1036        "glass.agent.new-session",
1037        "glass.agent.clone-session",
1038        "glass.agent.fork",
1039        "glass.agent.switch-session",
1040        "glass.agent.name",
1041        "glass.editor.open",
1042        "glass.editor.replace",
1043        "glass.editor.save",
1044        "glass.process.restart",
1045        "glass.process.input",
1046        "glass.process.resize",
1047        "glass.browser.start",
1048        "glass.browser.attach",
1049        "glass.browser.reconnect",
1050        "glass.browser.stop",
1051        "glass.browser.target.select",
1052        "glass.browser.navigate",
1053        "glass.browser.act",
1054        "glass.workflow.run",
1055        "glass.workflow.pause",
1056        "glass.workflow.resume",
1057        "glass.workflow.cancel",
1058        "glass.memory.forget",
1059    ];
1060    READ.iter()
1061        .map(|name| service_descriptor(name, false))
1062        .chain(MUTATE.iter().map(|name| service_descriptor(name, true)))
1063        .collect()
1064}
1065
1066fn service_descriptor(name: &str, mutating: bool) -> ToolDescriptor {
1067    ToolDescriptor {
1068        name: name.into(),
1069        description: format!("Resident Glass Dev operation {name}"),
1070        input_schema: serde_json::json!({"type":"object"}),
1071        mutating,
1072        available: true,
1073        unavailable_reason: None,
1074    }
1075}
1076
1077fn required_string<'a>(call: &'a ToolCall, name: &str) -> DevelopmentResult<&'a str> {
1078    call.arguments
1079        .get(name)
1080        .and_then(Value::as_str)
1081        .filter(|value| !value.is_empty() && value.len() <= 64 * 1024 && !value.contains('\0'))
1082        .ok_or_else(|| {
1083            DevelopmentError::InvalidInput(format!("{} requires bounded string {name}", call.name))
1084        })
1085}
1086
1087fn optional_string<'a>(call: &'a ToolCall, name: &str) -> Option<&'a str> {
1088    call.arguments.get(name).and_then(Value::as_str)
1089}
1090
1091fn required_value<'a>(call: &'a ToolCall, name: &str) -> DevelopmentResult<&'a Value> {
1092    call.arguments
1093        .get(name)
1094        .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))
1095}
1096
1097fn value_map(
1098    call: &ToolCall,
1099    name: &str,
1100) -> DevelopmentResult<std::collections::BTreeMap<String, Value>> {
1101    match call.arguments.get(name) {
1102        None => Ok(std::collections::BTreeMap::new()),
1103        Some(value) => serde_json::from_value(value.clone()).map_err(DevelopmentError::from),
1104    }
1105}
1106
1107fn boolean(call: &ToolCall, name: &str, default: bool) -> bool {
1108    call.arguments
1109        .get(name)
1110        .and_then(Value::as_bool)
1111        .unwrap_or(default)
1112}
1113
1114fn unsigned(call: &ToolCall, name: &str, default: u64) -> DevelopmentResult<u64> {
1115    let value = call
1116        .arguments
1117        .get(name)
1118        .and_then(Value::as_u64)
1119        .unwrap_or(default);
1120    (value <= i64::MAX as u64).then_some(value).ok_or_else(|| {
1121        DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
1122    })
1123}
1124
1125fn integer(call: &ToolCall, name: &str) -> DevelopmentResult<i64> {
1126    call.arguments
1127        .get(name)
1128        .and_then(Value::as_i64)
1129        .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))
1130}
1131
1132fn u32_value(call: &ToolCall, name: &str) -> DevelopmentResult<u32> {
1133    u32::try_from(unsigned(call, name, 0)?).map_err(|_| {
1134        DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
1135    })
1136}
1137
1138fn u16_value(call: &ToolCall, name: &str) -> DevelopmentResult<u16> {
1139    let value = u16::try_from(unsigned(call, name, 0)?).map_err(|_| {
1140        DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
1141    })?;
1142    (value > 0).then_some(value).ok_or_else(|| {
1143        DevelopmentError::InvalidInput(format!("{}.{} must be non-zero", call.name, name))
1144    })
1145}
1146
1147fn position(
1148    call: &ToolCall,
1149    name: &str,
1150) -> DevelopmentResult<glass_browser::development::DiagnosticPosition> {
1151    serde_json::from_value(required_value(call, name)?.clone()).map_err(DevelopmentError::from)
1152}
1153
1154fn value_array_or_empty(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<Value>> {
1155    match call.arguments.get(name) {
1156        None => Ok(Vec::new()),
1157        Some(Value::Array(values)) if values.len() <= 512 => Ok(values.clone()),
1158        Some(_) => Err(DevelopmentError::InvalidInput(format!(
1159            "{}.{} must be an array of at most 512 values",
1160            call.name, name
1161        ))),
1162    }
1163}
1164
1165fn number(call: &ToolCall, name: &str, default: f64) -> DevelopmentResult<f64> {
1166    let value = call
1167        .arguments
1168        .get(name)
1169        .and_then(Value::as_f64)
1170        .unwrap_or(default);
1171    value.is_finite().then_some(value).ok_or_else(|| {
1172        DevelopmentError::InvalidInput(format!("{}.{} must be finite", call.name, name))
1173    })
1174}
1175
1176fn string_array(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<String>> {
1177    let values = call
1178        .arguments
1179        .get(name)
1180        .and_then(Value::as_array)
1181        .filter(|values| !values.is_empty() && values.len() <= 256)
1182        .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))?;
1183    values
1184        .iter()
1185        .map(|value| {
1186            value
1187                .as_str()
1188                .filter(|value| !value.is_empty() && value.len() <= 4096 && !value.contains('\0'))
1189                .map(str::to_string)
1190                .ok_or_else(|| DevelopmentError::InvalidInput(format!("invalid {name} item")))
1191        })
1192        .collect()
1193}
1194
1195fn string_array_or_empty(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<String>> {
1196    if call.arguments.get(name).is_none() {
1197        Ok(Vec::new())
1198    } else {
1199        string_array(call, name)
1200    }
1201}
1202
1203fn unsigned_array(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<u64>> {
1204    call.arguments
1205        .get(name)
1206        .and_then(Value::as_array)
1207        .filter(|values| !values.is_empty() && values.len() <= 512)
1208        .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))?
1209        .iter()
1210        .map(|value| {
1211            value
1212                .as_u64()
1213                .filter(|value| *value > 0)
1214                .ok_or_else(|| DevelopmentError::InvalidInput(format!("invalid {name} item")))
1215        })
1216        .collect()
1217}
1218
1219fn timeout(call: &ToolCall, maximum_seconds: u64) -> DevelopmentResult<Option<Duration>> {
1220    call.arguments
1221        .get("timeoutSeconds")
1222        .map(|_| unsigned(call, "timeoutSeconds", maximum_seconds))
1223        .transpose()?
1224        .map(|seconds| {
1225            if seconds == 0 || seconds > maximum_seconds {
1226                Err(DevelopmentError::InvalidInput(format!(
1227                    "timeoutSeconds must be 1..={maximum_seconds}"
1228                )))
1229            } else {
1230                Ok(Duration::from_secs(seconds))
1231            }
1232        })
1233        .transpose()
1234}
1235
1236fn parse_kernel_kind(value: &str) -> DevelopmentResult<KernelKind> {
1237    match value {
1238        "python" => Ok(KernelKind::Python),
1239        "javascript" => Ok(KernelKind::JavaScript),
1240        "shell" => Ok(KernelKind::Shell),
1241        "sql" => Ok(KernelKind::Sql),
1242        _ => Err(DevelopmentError::InvalidInput(
1243            "kernel kind must be python, javascript, shell, or sql".into(),
1244        )),
1245    }
1246}
1247
1248fn normalized_actor_id(value: &str) -> String {
1249    let normalized: String = value
1250        .chars()
1251        .filter(|character| character.is_ascii_alphanumeric() || "-_.".contains(*character))
1252        .take(128)
1253        .collect();
1254    if normalized.is_empty() {
1255        "actor".into()
1256    } else {
1257        normalized
1258    }
1259}
1260
1261fn agent_id(
1262    workspace: &mut DevelopmentWorkspace,
1263    value: &str,
1264) -> DevelopmentResult<crate::agents::AgentId> {
1265    workspace
1266        .agents()
1267        .list()?
1268        .into_iter()
1269        .find(|snapshot| snapshot.id.as_str() == value)
1270        .map(|snapshot| snapshot.id)
1271        .ok_or_else(|| DevelopmentError::NotFound(format!("agent {value}")))
1272}
1273
1274fn agent_request(
1275    workspace: &mut DevelopmentWorkspace,
1276    call: &ToolCall,
1277    request: HarnessRequest,
1278) -> DevelopmentResult<Value> {
1279    let id = agent_id(workspace, required_string(call, "agentId")?)?;
1280    map_service(workspace.agents().request(&id, request))?;
1281    Ok(serde_json::json!({"queued":true}))
1282}
1283
1284fn map_service<T: serde::Serialize, E: std::fmt::Display>(
1285    result: Result<T, E>,
1286) -> DevelopmentResult<Value> {
1287    result
1288        .map_err(|error| DevelopmentError::Process(error.to_string()))
1289        .and_then(|value| serde_json::to_value(value).map_err(DevelopmentError::from))
1290}
1291
1292fn map_debug<T: serde::Serialize>(
1293    result: crate::debugger::DebugResult<T>,
1294) -> DevelopmentResult<Value> {
1295    map_service(result)
1296}
1297
1298fn debugger<'a>(
1299    workspace: &'a mut DevelopmentWorkspace,
1300    name: &str,
1301) -> DevelopmentResult<&'a mut crate::debugger::DebuggerSession> {
1302    workspace
1303        .debugger_mut(name)
1304        .map_err(|error| DevelopmentError::Process(error.to_string()))
1305}
1306
1307fn git_value<T: serde::Serialize>(
1308    git: Option<&crate::git::GitService>,
1309    operation: impl FnOnce(&crate::git::GitService) -> crate::git::GitResult<T>,
1310) -> DevelopmentResult<Value> {
1311    map_service(operation(git.ok_or_else(|| {
1312        DevelopmentError::NotFound("Git repository".into())
1313    })?))
1314}
1315
1316fn git_mutation(
1317    git: Option<&crate::git::GitService>,
1318    operation: impl FnOnce(&crate::git::GitService) -> crate::git::GitResult<()>,
1319) -> DevelopmentResult<()> {
1320    operation(git.ok_or_else(|| DevelopmentError::NotFound("Git repository".into()))?)
1321        .map_err(|error| DevelopmentError::Process(error.to_string()))
1322}
1323
1324#[cfg(test)]
1325mod tests {
1326    use super::*;
1327    use glass_browser::development::Actor;
1328    use std::sync::atomic::{AtomicU64, Ordering};
1329
1330    static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
1331
1332    fn workspace() -> DevelopmentWorkspace {
1333        let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
1334        let root = std::env::temp_dir().join(format!(
1335            "glass-tool-router-{}-{sequence}",
1336            std::process::id()
1337        ));
1338        std::fs::create_dir_all(&root).unwrap();
1339        std::fs::write(
1340            root.join("Cargo.toml"),
1341            "[package]\nname='x'\nversion='0.1.0'\n",
1342        )
1343        .unwrap();
1344        DevelopmentWorkspace::open(root).unwrap()
1345    }
1346
1347    fn context(workspace: &DevelopmentWorkspace, mutate: bool) -> DevelopmentToolContext {
1348        DevelopmentToolContext {
1349            authorization: ToolAuthorization {
1350                actor: Actor::embedded(),
1351                allow_mutation: mutate,
1352                confirmed: mutate,
1353            },
1354            expected_generation: workspace.generation(),
1355            expected_project_revision: workspace.project().revision(),
1356        }
1357    }
1358
1359    #[test]
1360    fn router_rejects_stale_or_unauthorized_mutations() {
1361        let mut workspace = workspace();
1362        let router = DevelopmentToolRouter::default();
1363        let call = ToolCall {
1364            id: "write-1".into(),
1365            name: "glass.file.write".into(),
1366            arguments: serde_json::json!({"path":"src/lib.rs","content":"pub fn ok() {}\n"}),
1367        };
1368        let read_only = context(&workspace, false);
1369        assert!(router.execute(&mut workspace, &call, &read_only).is_err());
1370        let mut stale = context(&workspace, true);
1371        stale.expected_project_revision = stale.expected_project_revision.saturating_add(1);
1372        assert!(router.execute(&mut workspace, &call, &stale).is_err());
1373        let valid = context(&workspace, true);
1374        workspace.execute_tool(&call, &valid).unwrap();
1375        assert!(workspace.root().join("src/lib.rs").exists());
1376        let replay = workspace.intelligence().replay(0, 16).unwrap();
1377        assert_eq!(
1378            replay
1379                .iter()
1380                .map(|event| event.kind.as_str())
1381                .collect::<Vec<_>>(),
1382            vec!["called", "completed"]
1383        );
1384        assert!(
1385            workspace
1386                .intelligence()
1387                .path("repository:root", "tool:write-1")
1388                .is_ok()
1389        );
1390    }
1391
1392    #[test]
1393    fn router_uses_resident_kernel_and_test_services() {
1394        let mut workspace = workspace();
1395        let router = DevelopmentToolRouter::default();
1396        let start = ToolCall {
1397            id: "kernel-1".into(),
1398            name: "glass.eval.start".into(),
1399            arguments: serde_json::json!({"name":"analysis","kind":"sql"}),
1400        };
1401        let mutation = context(&workspace, true);
1402        router.execute(&mut workspace, &start, &mutation).unwrap();
1403        let execute = ToolCall {
1404            id: "kernel-2".into(),
1405            name: "glass.eval.execute".into(),
1406            arguments: serde_json::json!({"name":"analysis","code":"SELECT 40 + 2 AS answer"}),
1407        };
1408        let result = router.execute(&mut workspace, &execute, &mutation).unwrap();
1409        assert_eq!(result["value"][0]["answer"], 42);
1410        assert!(
1411            router
1412                .descriptors()
1413                .iter()
1414                .any(|descriptor| descriptor.name == "glass.debug.launch")
1415        );
1416    }
1417
1418    #[test]
1419    fn router_exposes_shared_editor_process_browser_and_complete_lsp_tools() {
1420        let mut workspace = workspace();
1421        std::fs::create_dir_all(workspace.root().join("src")).unwrap();
1422        std::fs::write(workspace.root().join("src/lib.rs"), "pub fn old() {}\n").unwrap();
1423        let router = DevelopmentToolRouter::default();
1424        let descriptors = router.descriptors();
1425        for name in [
1426            "glass.editor.open",
1427            "glass.editor.replace",
1428            "glass.editor.save",
1429            "glass.process.restart",
1430            "glass.process.input",
1431            "glass.process.resize",
1432            "glass.process.health",
1433            "glass.process.ports",
1434            "glass.browser.observe",
1435            "glass.browser.snapshot",
1436            "glass.browser.attach",
1437            "glass.browser.reconnect",
1438            "glass.browser.semantic",
1439            "glass.browser.diff",
1440            "glass.browser.navigate",
1441            "glass.browser.act",
1442            "glass.workflow.list",
1443            "glass.workflow.run",
1444            "glass.workflow.pause",
1445            "glass.workflow.resume",
1446            "glass.workflow.cancel",
1447            "glass.workflow.verify",
1448            "glass.workflow.record",
1449            "glass.memory.retrieve",
1450            "glass.memory.explain",
1451            "glass.memory.forget",
1452            "glass.semantic.inspect",
1453            "glass.semantic.diff",
1454            "glass.semantic.links",
1455            "glass.lsp.start",
1456            "glass.lsp.stop",
1457            "glass.lsp.list",
1458            "glass.lsp.events",
1459            "glass.lsp.definition",
1460            "glass.lsp.declaration",
1461            "glass.lsp.implementation",
1462            "glass.lsp.references",
1463            "glass.lsp.document_symbols",
1464            "glass.lsp.workspace_symbols",
1465            "glass.lsp.signature_help",
1466            "glass.lsp.code_actions",
1467            "glass.lsp.formatting",
1468            "glass.lsp.range_formatting",
1469            "glass.lsp.semantic_tokens",
1470            "glass.lsp.rename",
1471            "glass.lsp.raw",
1472            "glass.debug.configuration_done",
1473            "glass.debug.restart",
1474            "glass.debug.breakpoint.remove",
1475            "glass.debug.exception.set",
1476            "glass.debug.threads",
1477            "glass.debug.disconnect",
1478            "glass.debug.terminate",
1479            "glass.agent.model",
1480            "glass.agent.thinking",
1481            "glass.agent.new-session",
1482            "glass.agent.clone-session",
1483            "glass.agent.fork",
1484            "glass.agent.switch-session",
1485            "glass.agent.messages",
1486            "glass.agent.entries",
1487            "glass.agent.stats",
1488            "glass.agent.name",
1489        ] {
1490            let descriptor = descriptors
1491                .iter()
1492                .find(|descriptor| descriptor.name == name)
1493                .unwrap_or_else(|| panic!("missing {name}"));
1494            assert!(
1495                descriptor.available,
1496                "{name} must execute, not be a placeholder"
1497            );
1498        }
1499
1500        for (id, name, arguments) in [
1501            (
1502                "open",
1503                "glass.editor.open",
1504                serde_json::json!({"path":"src/lib.rs"}),
1505            ),
1506            (
1507                "replace",
1508                "glass.editor.replace",
1509                serde_json::json!({"path":"src/lib.rs","oldText":"old","newText":"resident"}),
1510            ),
1511            (
1512                "save",
1513                "glass.editor.save",
1514                serde_json::json!({"path":"src/lib.rs"}),
1515            ),
1516        ] {
1517            let call = ToolCall {
1518                id: id.into(),
1519                name: name.into(),
1520                arguments,
1521            };
1522            let authorized = context(&workspace, true);
1523            router.execute(&mut workspace, &call, &authorized).unwrap();
1524        }
1525        assert_eq!(
1526            std::fs::read_to_string(workspace.root().join("src/lib.rs")).unwrap(),
1527            "pub fn resident() {}\n"
1528        );
1529    }
1530}