@dot-agent/language-server 0.2.0

package/features/definition.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { nodesOfType, nodeToRange, wordAtPosition } = require('../parser');
+
+function provideDefinition(langId, tree, text, uri, position) {
+    if (!tree) return null;
+
+    const { word } = wordAtPosition(text, position.line, position.character);
+    if (!word) return null;
+
+    let targetNode = null;
+
+    if (langId === 'behavior') {
+        targetNode = nodesOfType(tree, 'state_decl')
+            .find(n => n.childForFieldName('name')?.text === word);
+    } else if (langId === 'agent') {
+        if (!/^[A-Z]/.test(word) && !word.includes('.')) return null;
+        targetNode = nodesOfType(tree, 'type_decl')
+            .find(n => n.childForFieldName('name')?.text === word);
+    }
+
+    if (!targetNode) return null;
+    return { uri, range: nodeToRange(targetNode) };
+}
+
+module.exports = { provideDefinition };

package/features/diagnostics.js

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { DiagnosticSeverity } = require('vscode-languageserver');
+const { nodesOfType, nodeToRange } = require('../parser');
+
+const DEPRECATED_AGENT_KW = new Set([
+    'do', 'server', 'endpoint', 'author', 'version', 'requirements', 'step',
+    'softwareVersion', 'applicationCategory', 'character', 'publishingPrinciples',
+]);
+
+const STRICT_BLOCK_TYPES = {
+    input_block:        'input',
+    output_block:       'output',
+    requires_block:     'requires',
+    capabilities_block: 'capabilities',
+};
+
+function diagnoseAgent(tree, text) {
+    const diagnostics = [];
+
+    // ── Deprecated keywords: line scan (no tree-sitter benefit here) ──────────
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const stripped = raw.split('//')[0].trim();
+        if (!stripped) continue;
+        const wordM = stripped.match(/^([a-zA-Z0-9_.-]+)\b/);
+        if (!wordM) continue;
+        const word = wordM[1];
+        if (DEPRECATED_AGENT_KW.has(word)) {
+            const col = raw.indexOf(word);
+            diagnostics.push({
+                range: { start: { line: i, character: col }, end: { line: i, character: col + word.length } },
+                message: `The keyword '${word}' is deprecated or invalid in the current .agent specification.`,
+                severity: DiagnosticSeverity.Error,
+                source: 'agent-dsl',
+            });
+        }
+    }
+
+    // ── Strict block validation ───────────────────────────────────────────────
+    const declaredTypes = new Set(
+        nodesOfType(tree, 'type_decl')
+            .map(n => n.childForFieldName('name')?.text)
+            .filter(Boolean)
+    );
+
+    for (const [blockType, blockName] of Object.entries(STRICT_BLOCK_TYPES)) {
+        for (const blockNode of nodesOfType(tree, blockType)) {
+            // Syntax errors inside the block
+            for (const errorNode of blockNode.descendantsOfType('ERROR')) {
+                diagnostics.push({
+                    range: nodeToRange(errorNode),
+                    message: `Syntax error in '${blockName}' block. Expected: Type or Type "Description", or compact: Type1, Type2.`,
+                    severity: DiagnosticSeverity.Error,
+                    source: 'agent-dsl',
+                });
+            }
+
+            // Undeclared type references (semantic warning)
+            if (declaredTypes.size > 0) {
+                for (const typeRefNode of blockNode.descendantsOfType('type_ref')) {
+                    const idNode = typeRefNode.firstNamedChild;
+                    if (!idNode) continue;
+                    const typeName = idNode.text;
+                    if (!declaredTypes.has(typeName)) {
+                        diagnostics.push({
+                            range: nodeToRange(idNode),
+                            message: `Type '${typeName}' is not declared in this file (assuming native or external).`,
+                            severity: DiagnosticSeverity.Warning,
+                            source: 'agent-dsl',
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    return diagnostics;
+}
+
+function diagnoseFlow(tree) {
+    const diagnostics = [];
+
+    // ── Rule 1: Dangling transitions ──────────────────────────────────────────
+    const definedStates = new Set(
+        nodesOfType(tree, 'state_decl')
+            .map(n => n.childForFieldName('name')?.text)
+            .filter(Boolean)
+    );
+
+    function checkTransitionTarget(stateNode) {
+        if (!stateNode) return;
+        const target = stateNode.text;
+        if (!definedStates.has(target)) {
+            const external = target.includes('.');
+            diagnostics.push({
+                range: nodeToRange(stateNode),
+                message: external
+                    ? `State '${target}' is not defined locally (assuming external flow reference).`
+                    : `State '${target}' is not defined in this file.`,
+                severity: external ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error,
+                source: 'behavior-dsl',
+            });
+        }
+    }
+
+    for (const n of nodesOfType(tree, 'transition_stmt')) {
+        checkTransitionTarget(n.childForFieldName('state'));
+    }
+    for (const n of nodesOfType(tree, 'intent_trigger')) {
+        // inline form: on intent "..." next <state>
+        checkTransitionTarget(n.childForFieldName('state'));
+    }
+
+    // ── Rule 2: Dead-end interact ─────────────────────────────────────────────
+    for (const interactNode of nodesOfType(tree, 'interact_stmt')) {
+        let ancestor = interactNode.parent;
+        while (ancestor && ancestor.type !== 'state_decl') {
+            ancestor = ancestor.parent;
+        }
+        if (!ancestor) continue;
+
+        const hasNext   = ancestor.descendantsOfType('transition_stmt').length > 0;
+        const hasIntent = ancestor.descendantsOfType('intent_trigger').length > 0;
+        const hasOfftopic = ancestor.descendantsOfType('offtopic_stmt').length > 0;
+
+        if (!hasNext && !hasIntent && !hasOfftopic) {
+            diagnostics.push({
+                range: nodeToRange(interactNode),
+                message: "This state calls interact but has no 'transition' or 'on intent/offtopic'. This will trap the agent.",
+                severity: DiagnosticSeverity.Warning,
+                source: 'behavior-dsl',
+            });
+        }
+    }
+
+    return diagnostics;
+}
+
+function diagnose(langId, tree, text) {
+    if (!tree) return [];
+    if (langId === 'agent') return diagnoseAgent(tree, text);
+    if (langId === 'behavior')  return diagnoseFlow(tree);
+    return [];
+}
+
+module.exports = { diagnose };

package/features/formatting.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const BLOCK_HEADERS = /^(on\s+(intent|offtopic|fallback|complete|failed)|if|else|after|parallel)\b/;
+const TOP_LEVEL_LINE = /^(state|merge)\s|^on\s+event\b/;
+
+function formatBehavior(text) {
+    const edits = [];
+    const lines = text.split('\n');
+    let mode = 'PREAMBLE'; // PREAMBLE | STATE_BODY | NESTED_BODY
+
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        if (!trimmed) continue;
+
+        let expectedIndent;
+        if (TOP_LEVEL_LINE.test(trimmed)) {
+            mode = /^state\s/.test(trimmed) ? 'STATE_BODY' : 'PREAMBLE';
+            expectedIndent = 0;
+        } else if (mode === 'PREAMBLE') {
+            expectedIndent = 0;
+        } else if (mode === 'STATE_BODY') {
+            if (BLOCK_HEADERS.test(trimmed)) mode = 'NESTED_BODY';
+            expectedIndent = 2;
+        } else {
+            expectedIndent = BLOCK_HEADERS.test(trimmed) ? 2 : 4;
+        }
+
+        const actualIndent = raw.length - raw.trimStart().length;
+        if (actualIndent !== expectedIndent) {
+            edits.push({
+                range: { start: { line: i, character: 0 }, end: { line: i, character: actualIndent } },
+                newText: ' '.repeat(expectedIndent),
+            });
+        }
+    }
+    return edits;
+}
+
+function formatAgent(text) {
+    const edits = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        if (!raw.trim()) continue;
+        const expectedIndent = /^\s/.test(raw) ? 2 : 0;
+        const actualIndent = raw.length - raw.trimStart().length;
+        if (actualIndent !== expectedIndent) {
+            edits.push({
+                range: { start: { line: i, character: 0 }, end: { line: i, character: actualIndent } },
+                newText: ' '.repeat(expectedIndent),
+            });
+        }
+    }
+    return edits;
+}
+
+function format(langId, text) {
+    if (langId === 'behavior') return formatBehavior(text);
+    if (langId === 'agent') return formatAgent(text);
+    return [];
+}
+
+module.exports = { format };

package/features/hover.js

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { MarkupKind } = require('vscode-languageserver');
+
+const AGENT_DOCS = {
+    'agent':        '**`agent name`**\n\nDeclares a new agent. The central node of the manifest.',
+    'domain':       '**`domain url`**\n\nDeclares the canonical domain for this agent, establishing cryptographic identity and ownership.',
+    'license':      '**`license type`**\n\nDeclares the license under which this agent is distributed (e.g., MIT, Copyright).',
+    'terms':        '**`terms url`**\n\nLink to the terms of service.',
+    'privacy':      '**`privacy url`**\n\nLink to the privacy policy.',
+    'description':  '**`description`**\n\nA brief description of the agent, used by the Runtime for semantic indexing.',
+    'behavior':     '**`behavior file.behavior`**\n\nThe `.behavior` file that manages the state and transitions of this agent.',
+    'requires':     '**`requires Type`**\n\nTypes (native or custom) that the Runtime must ensure exist in context before triggering the `.behavior`.',
+    'input':        '**`input Type`**\n\nThe input data types expected for this agent to operate.',
+    'capabilities': '**`capabilities Action`**\n\nThe Actions or capabilities this agent can execute. Also acts as a Sandboxing Contract.',
+    'output':       '**`output Type`**\n\nThe data type this agent returns.',
+    'type':         '**`type name`**\n\nDeclares a custom type to anchor custom typing to Wikidata or Schema.org.',
+    'concept':      '**`concept url`**\n\nThe Wikidata or Schema.org concept URL this type maps to.',
+    'schema':       '**`schema file.json`**\n\nA JSON schema file for this type.',
+};
+
+const BEHAVIOR_DOCS = {
+    'merge':       '**`merge "file.behavior"`**\n\nIncludes another `.behavior` file. Must appear before any `state` or `on event` declarations (preamble-only, eager loading).',
+    'state':       '**`state name`**\n\nDeclares a named state. States contain the logic that runs while the agent is in that state.',
+    'on':          '**`on event|intent|offtopic|fallback|complete|failed`**\n\nBinds a handler to a trigger. Top-level: `on event`. Inside a state: `on intent`, `on offtopic`, `on fallback`. After parallel: `on complete`, `on failed`.',
+    'run':         '**`run script|subagent|tool "target"`**\n\nExecutes a script, subagent, or tool. Accepts optional modifiers: `silent`, `in background`, `each collection`.',
+    'guide':       '**`guide "text"`**\n\nInjects a system-level instruction into the conversation context, shaping the agent\'s persona or approach without being visible as a reply.',
+    'teach':       '**`teach "text"`**\n\nAdds a fact or constraint to the agent\'s working knowledge for the duration of this state.',
+    'goal':        '**`goal "text"`**\n\nSets the agent\'s objective for this state, used by the runtime for planning and alignment checks.',
+    'interact':    '**`interact [requiring "text"]`**\n\nPauses execution and waits for user input. Optionally enforces a requirement before continuing.',
+    'set':         '**`set domain.var = value`**\n\nAssigns a value to a memory variable. Domains: `context`, `session`, `worksession`, `user`.',
+    'context':     '**`context`** memory domain — scoped to the current agent run.',
+    'session':     '**`session`** memory domain — persists for the user\'s current session.',
+    'worksession': '**`worksession`** memory domain — persists across a task-oriented work session (isolated per task).',
+    'user':        '**`user`** memory domain — persists across sessions for a given user.',
+    'transition':  '**`transition to state`**\n\nTransitions immediately to the named state.',
+    'if':          '**`if condition`**\n\nConditional execution. Condition can use `==`, `!=`, `>`, `<`, `>=`, `<=`, `and`, `or`.',
+    'else':        '**`else`**\n\nAlternative branch of an `if` statement.',
+    'after':       '**`after N prompts`**\n\n[Experimental] Executes a block after N user prompts have occurred in this state.',
+    'parallel':    '**`parallel`**\n\n[Experimental] Runs a block of `run` statements concurrently. Follow with `on complete` and `on failed` handlers.',
+    'apply':       '**`apply css|html|video "text"`**\n\nApplies a UI manipulation to a CSS selector, HTML element, or video element.',
+    'remove':      '**`remove css|html|video "text"`**\n\nRemoves a UI element by selector or reference.',
+};
+
+function provideHover(langId, text, position) {
+    const lines = text.split('\n');
+    const line = lines[position.line] || '';
+    const ch = position.character;
+
+    // Find word at cursor
+    let start = ch, end = ch;
+    while (start > 0 && /[a-zA-Z0-9_]/.test(line[start - 1])) start--;
+    while (end < line.length && /[a-zA-Z0-9_]/.test(line[end])) end++;
+    const word = line.slice(start, end);
+    if (!word) return null;
+
+    const docs = langId === 'agent' ? AGENT_DOCS : BEHAVIOR_DOCS;
+    const doc = docs[word];
+    if (!doc) return null;
+
+    return {
+        contents: { kind: MarkupKind.Markdown, value: doc },
+        range: {
+            start: { line: position.line, character: start },
+            end:   { line: position.line, character: end },
+        },
+    };
+}
+
+module.exports = { provideHover };

package/features/links.js

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { fileURLToPath, pathToFileURL } = require('url');
+const path = require('path');
+const { nodesOfType, nodeToRange } = require('../parser');
+
+function provideDocumentLinks(langId, tree, docUri) {
+    if (!tree) return [];
+
+    let docDir;
+    try {
+        docDir = path.dirname(fileURLToPath(docUri));
+    } catch {
+        return [];
+    }
+
+    const links = [];
+
+    function addLink(fileNode, rawText) {
+        const filename = rawText.replace(/^"|"$/g, '');   // strip optional quotes
+        if (!filename) return;
+        links.push({
+            range: nodeToRange(fileNode),
+            target: pathToFileURL(path.resolve(docDir, filename)).toString(),
+        });
+    }
+
+    if (langId === 'agent') {
+        for (const node of nodesOfType(tree, 'behavior_block')) {
+            const fileNode = node.childForFieldName('file');
+            if (fileNode) addLink(fileNode, fileNode.text);
+        }
+        for (const node of nodesOfType(tree, 'schema_prop')) {
+            const fileNode = node.childForFieldName('file');
+            if (fileNode) addLink(fileNode, fileNode.text);
+        }
+    }
+
+    if (langId === 'behavior') {
+        for (const node of nodesOfType(tree, 'merge_decl')) {
+            const pathNode = node.childForFieldName('path');
+            if (pathNode) addLink(pathNode, pathNode.text);
+        }
+        for (const node of nodesOfType(tree, 'run_stmt')) {
+            const runTypeNode = node.childForFieldName('run_type');
+            if (runTypeNode?.text !== 'script') continue;
+            const targetNode = node.childForFieldName('target');
+            if (targetNode) addLink(targetNode, targetNode.text);
+        }
+    }
+
+    return links;
+}
+
+module.exports = { provideDocumentLinks };

package/features/references.js

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { nodesOfType, nodeToRange, wordAtPosition } = require('../parser');
+
+function provideReferences(langId, tree, text, uri, position) {
+    if (!tree) return [];
+
+    const { word } = wordAtPosition(text, position.line, position.character);
+    if (!word) return [];
+
+    const locations = [];
+
+    function add(node) {
+        locations.push({ uri, range: nodeToRange(node) });
+    }
+
+    if (langId === 'behavior') {
+        // Declaration
+        for (const n of nodesOfType(tree, 'state_decl')) {
+            const nameNode = n.childForFieldName('name');
+            if (nameNode?.text === word) add(nameNode);
+        }
+        // Direct transitions: next <state>
+        for (const n of nodesOfType(tree, 'transition_stmt')) {
+            const stateNode = n.childForFieldName('state');
+            if (stateNode?.text === word) add(stateNode);
+        }
+        // Inline intent handlers: on intent "..." next <state>
+        for (const n of nodesOfType(tree, 'intent_trigger')) {
+            const stateNode = n.childForFieldName('state');
+            if (stateNode?.text === word) add(stateNode);
+        }
+    } else if (langId === 'agent') {
+        // Declaration
+        for (const n of nodesOfType(tree, 'type_decl')) {
+            const nameNode = n.childForFieldName('name');
+            if (nameNode?.text === word) add(nameNode);
+        }
+        // All type_ref usages (input/output/requires/capabilities blocks and property types)
+        for (const n of nodesOfType(tree, 'type_ref')) {
+            const idNode = n.firstNamedChild;
+            if (idNode?.text === word) add(idNode);
+        }
+    }
+
+    return locations;
+}
+
+module.exports = { provideReferences };

package/features/rename.js

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { nodesOfType, nodeToRange, wordAtPosition } = require('../parser');
+
+function provideRenameEdits(langId, tree, text, uri, position, newName) {
+    if (!tree) return null;
+
+    const { word: oldName } = wordAtPosition(text, position.line, position.character);
+    if (!oldName) return null;
+
+    const edits = [];
+
+    function addEdit(node) {
+        edits.push({ range: nodeToRange(node), newText: newName });
+    }
+
+    if (langId === 'behavior') {
+        // Rename state declarations
+        for (const n of nodesOfType(tree, 'state_decl')) {
+            const nameNode = n.childForFieldName('name');
+            if (nameNode?.text === oldName) addEdit(nameNode);
+        }
+        // Rename transition targets
+        for (const n of nodesOfType(tree, 'transition_stmt')) {
+            const stateNode = n.childForFieldName('state');
+            if (stateNode?.text === oldName) addEdit(stateNode);
+        }
+        // Rename inline intent handler targets
+        for (const n of nodesOfType(tree, 'intent_trigger')) {
+            const stateNode = n.childForFieldName('state');
+            if (stateNode?.text === oldName) addEdit(stateNode);
+        }
+    } else if (langId === 'agent') {
+        // Rename type declarations
+        for (const n of nodesOfType(tree, 'type_decl')) {
+            const nameNode = n.childForFieldName('name');
+            if (nameNode?.text === oldName) addEdit(nameNode);
+        }
+        // Rename all type_ref usages
+        for (const n of nodesOfType(tree, 'type_ref')) {
+            const idNode = n.firstNamedChild;
+            if (idNode?.text === oldName) addEdit(idNode);
+        }
+    }
+
+    if (edits.length === 0) return null;
+    return { changes: { [uri]: edits } };
+}
+
+module.exports = { provideRenameEdits };

package/features/symbols.js

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { nodesOfType, nodeToRange } = require('../parser');
+
+// DocumentSymbol kind constants (LSP spec §3.17.5)
+const Kind = { Class: 5, Struct: 23, Event: 24 };
+
+function provideDocumentSymbols(langId, tree) {
+    if (!tree) return [];
+    const symbols = [];
+
+    if (langId === 'behavior') {
+        for (const node of nodesOfType(tree, 'state_decl')) {
+            const nameNode = node.childForFieldName('name');
+            if (!nameNode) continue;
+            symbols.push({
+                name: nameNode.text,
+                kind: Kind.Class,
+                range: nodeToRange(node),
+                selectionRange: nodeToRange(nameNode),
+            });
+        }
+        for (const node of nodesOfType(tree, 'trigger_decl')) {
+            const eventNode = node.childForFieldName('event');
+            if (!eventNode) continue;
+            const name = eventNode.text.replace(/^"|"$/g, '');
+            symbols.push({
+                name: `on event: ${name}`,
+                kind: Kind.Event,
+                range: nodeToRange(node),
+                selectionRange: nodeToRange(eventNode),
+            });
+        }
+    }
+
+    if (langId === 'agent') {
+        for (const node of nodesOfType(tree, 'agent_decl')) {
+            const nameNode = node.childForFieldName('name');
+            if (!nameNode) continue;
+            symbols.push({
+                name: nameNode.text,
+                kind: Kind.Class,
+                range: nodeToRange(node),
+                selectionRange: nodeToRange(nameNode),
+            });
+        }
+        for (const node of nodesOfType(tree, 'type_decl')) {
+            const nameNode = node.childForFieldName('name');
+            if (!nameNode) continue;
+            symbols.push({
+                name: nameNode.text,
+                kind: Kind.Struct,
+                range: nodeToRange(node),
+                selectionRange: nodeToRange(nameNode),
+            });
+        }
+    }
+
+    return symbols;
+}
+
+module.exports = { provideDocumentSymbols };