feat: add localization and test coverage for ToolPipe MCP integration

- Create package.nls.json with localized strings for extension UI
- Update package.json to use localization placeholders (%displayName%, %description%, etc.)
- Add comprehensive test suite for inline reference snippet rendering
- Tests cover: basic snippet rendering, backtick escaping, fence length calculation
- Tests verify: code blocks with language IDs, empty snippets, multiple backtick sequences
- All tests follow existing VS Code test patterns and conventions

Author: rupeshkumar-555

extensions/toolpipe-mcp-server/package.json

@@ -1,7 +1,7 @@
 {
   "name": "toolpipe-mcp-server",
-  "displayName": "ToolPipe MCP Server",
-  "description": "Integrates ToolPipe MCP Server - 120+ developer utilities via Model Context Protocol",
+  "displayName": "%displayName%",
+  "description": "%description%",
   "version": "1.0.0",
   "publisher": "vscode",
   "license": "MIT",
@@ -36,17 +36,17 @@
     "mcpServerDefinitionProviders": [
       {
         "id": "toolpipe",
-        "label": "ToolPipe MCP Server"
+        "label": "%mcpServerDefinition.label%"
       }
     ],
     "configuration": [
       {
-        "title": "ToolPipe MCP Server",
+        "title": "%configuration.title%",
         "properties": {
           "toolpipeMcpServer.enabled": {
             "type": "boolean",
             "default": true,
-            "description": "Enable ToolPipe MCP Server integration"
+            "description": "%configuration.enabled.description%"
           },
           "toolpipeMcpServer.mode": {
             "type": "string",
@@ -55,24 +55,24 @@
               "local"
             ],
             "default": "remote",
-            "description": "ToolPipe connection mode: 'remote' for cloud-hosted server, 'local' for npm-based server"
+            "description": "%configuration.mode.description%"
           },
   				"toolpipeMcpServer.remoteUrl": {
 					"type": "string",
 					"default": "",
-					"description": "Remote URL for ToolPipe MCP Server (HTTPS endpoint). Provide your own server URL, for example: https://example.com/mcp"
+					"description": "%configuration.remoteUrl.description%"
 				},
           "toolpipeMcpServer.localCommand": {
             "type": "string",
             "default": "npx",
-            "description": "Command to run local ToolPipe server (e.g., 'npx' or full path)"
+            "description": "%configuration.localCommand.description%"
           },
           "toolpipeMcpServer.localArgs": {
             "type": "array",
             "default": [
               "@cosai-labs/toolpipe-mcp-server"
             ],
-            "description": "Arguments for local ToolPipe server command"
+            "description": "%configuration.localArgs.description%"
           }
         }
       }

extensions/toolpipe-mcp-server/package.nls.json

@@ -0,0 +1,11 @@
+{
+	"displayName": "ToolPipe MCP Server",
+	"description": "Integrates ToolPipe MCP Server - 120+ developer utilities via Model Context Protocol",
+	"configuration.title": "ToolPipe MCP Server",
+	"configuration.enabled.description": "Enable ToolPipe MCP Server integration",
+	"configuration.mode.description": "ToolPipe connection mode: 'remote' for cloud-hosted server, 'local' for npm-based server",
+	"configuration.remoteUrl.description": "Remote URL for ToolPipe MCP Server (HTTPS endpoint). Provide your own server URL, for example: https://example.com/mcp",
+	"configuration.localCommand.description": "Command to run local ToolPipe server (e.g., 'npx' or full path)",
+	"configuration.localArgs.description": "Arguments for local ToolPipe server command",
+	"mcpServerDefinition.label": "ToolPipe MCP Server"
+}

src/vs/workbench/contrib/chat/test/common/widget/annotations.test.ts

@@ -315,4 +315,162 @@ suite('Annotations', function () {
 		});
 
 	});
+
+	suite('annotateSpecialMarkdownContent - inline references with snippets', () => {
+		test('inline reference with snippet renders code block', () => {
+			const result = annotateSpecialMarkdownContent([
+				content('Check out '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///example.ts'),
+					name: 'example.ts',
+					snippet: 'export const greeting = "hello world";',
+					languageId: 'typescript'
+				},
+				content(' for details'),
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			// Should contain the file reference
+			assert.ok(md.content.value.includes('[example.ts]'));
+			// Should contain the code fence with language ID
+			assert.ok(md.content.value.includes('```typescript'));
+			// Should contain the snippet
+			assert.ok(md.content.value.includes('export const greeting = "hello world";'));
+			// Should contain closing fence
+			assert.ok(md.content.value.includes('```'));
+		});
+
+		test('snippet with backticks uses appropriate fence length', () => {
+			const snippetWithBackticks = 'const code = `nested template literal`;';
+			const result = annotateSpecialMarkdownContent([
+				content('See '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///test.ts'),
+					name: 'test.ts',
+					snippet: snippetWithBackticks,
+					languageId: 'typescript'
+				},
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			const value = md.content.value;
+			// Should use 4 backticks (one more than the max run of 3 in the snippet)
+			assert.ok(value.includes('````typescript'));
+			assert.ok(value.includes(snippetWithBackticks));
+			assert.ok(value.includes('````'));
+		});
+
+		test('snippet with multiple backtick sequences uses longest length', () => {
+			const snippetWithMultipleBackticks = 'const a = ``; const b = ```; const c = `;';
+			const result = annotateSpecialMarkdownContent([
+				content('Example: '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///multi.ts'),
+					name: 'multi.ts',
+					snippet: snippetWithMultipleBackticks,
+					languageId: 'typescript'
+				},
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			const value = md.content.value;
+			// Should use 4 backticks (one more than the max run of 3)
+			assert.ok(value.includes('````typescript'));
+			assert.ok(value.includes(snippetWithMultipleBackticks));
+			assert.ok(value.includes('````'));
+		});
+
+		test('snippet without backticks uses standard 3-backtick fence', () => {
+			const cleanSnippet = 'function hello() {\n  console.log("world");\n}';
+			const result = annotateSpecialMarkdownContent([
+				content('Function: '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///func.ts'),
+					name: 'func.ts',
+					snippet: cleanSnippet,
+					languageId: 'typescript'
+				},
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			const value = md.content.value;
+			// Should use standard 3-backtick fence
+			assert.ok(value.includes('```typescript'));
+			assert.ok(value.includes(cleanSnippet));
+			// Count occurrences of closing fence
+			const closeMatches = value.match(/^```$/gm);
+			assert.ok(closeMatches && closeMatches.length >= 1, 'Should have at least one closing fence');
+		});
+
+		test('snippet with code block markers renders with longer fence', () => {
+			const snippetWithCodeBlock = 'const desc = "```javascript\ncode\n```";';
+			const result = annotateSpecialMarkdownContent([
+				content('Code: '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///code.ts'),
+					name: 'code.ts',
+					snippet: snippetWithCodeBlock,
+					languageId: 'typescript'
+				},
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			const value = md.content.value;
+			// Should use 4 backticks to escape the 3-backtick sequence inside
+			assert.ok(value.includes('````typescript'));
+			assert.ok(value.includes(snippetWithCodeBlock));
+			assert.ok(value.includes('````'));
+		});
+
+		test('snippet without language ID still renders with backtick escaping', () => {
+			const snippetWithBackticks = 'const template = `Hello ${name}`;';
+			const result = annotateSpecialMarkdownContent([
+				content('Value: '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///value.js'),
+					name: 'value.js',
+					snippet: snippetWithBackticks
+					// Note: no languageId provided
+				},
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			const value = md.content.value;
+			// Should use 4 backticks even without explicit language
+			assert.ok(value.includes('````'));
+			assert.ok(value.includes(snippetWithBackticks));
+		});
+
+		test('empty snippet still renders correctly', () => {
+			const result = annotateSpecialMarkdownContent([
+				content('Example: '),
+				{
+					kind: 'inlineReference',
+					inlineReference: URI.parse('file:///empty.ts'),
+					name: 'empty.ts',
+					snippet: '',
+					languageId: 'typescript'
+				},
+			]);
+
+			assert.strictEqual(result.length, 1);
+			const md = result[0] as IChatMarkdownContent;
+			const value = md.content.value;
+			// Should still have fence markers for empty content
+			assert.ok(value.includes('```typescript'));
+			assert.ok(value.includes('```'));
+		});
+	});
 });