From 3cb8d9d856c8fbf8931d3b1b79fb9b1baf242a84 Mon Sep 17 00:00:00 2001
From: tomaszgolebiowski <37900990+tomaszgolebiowski@users.noreply.github.com>
Date: Mon, 6 Jan 2025 09:34:05 +0100
Subject: [PATCH] Autocomplete (#166)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- implemented the agent protocols for autocompletions
- inline text changes that can be accepted with the `Tab` keyboard press
(`lalt+,` for rotating suggestions if there is more than one)
- explicitly trigger completion suggestions (`lalt+.`)
- user option to enable/disable Autocompletions
- telemetry to compute CAR
- tests

## Test plan
- Create a new solution
- Start adding code
- Check if 'grey code' with suggestions appears
- Accept the suggestions by pressing `Tab`
- Reject the suggestion by pressing `Esc`
<!-- REQUIRED; info at
https://docs-legacy.sourcegraph.com/dev/background-information/testing_principles
-->

---------

Co-authored-by: Tomasz Gołębiowski <tgolebiowski@virtuslab.com>
---
 agent/agent.version                           |   2 +-
 src/Cody.Core/Agent/IAgentService.cs          |  18 +-
 src/Cody.Core/Agent/NotificationHandlers.cs   |   8 +-
 .../Agent/Protocol/AutocompleteItem.cs        |  11 +
 .../Agent/Protocol/AutocompleteParams.cs      |  27 ++
 .../Agent/Protocol/AutocompleteResult.cs      |  12 +
 .../Protocol/CompletionBookkeepingEvent.cs    |   9 +
 .../Agent/Protocol/CompletionItemInfo.cs      |  14 +
 .../Agent/Protocol/CompletionItemParams.cs    |   9 +
 .../Agent/Protocol/GetDocumentsParams.cs      |  10 +
 .../Agent/Protocol/GetDocumentsResult.cs      |  10 +
 .../Agent/Protocol/SelectedCompletionInfo.cs  |  12 +
 src/Cody.Core/Cody.Core.csproj                |  11 +
 src/Cody.Core/Common/StringExtensions.cs      |  23 ++
 .../DocumentSync/DocumentSyncCallback.cs      |  24 +-
 .../Settings/IUserSettingsService.cs          |   1 +
 src/Cody.Core/Settings/UserSettingsService.cs |  10 +
 src/Cody.Core/Trace/FileTraceListener.cs      |   3 +-
 src/Cody.Core/Trace/LogioTraceListener.cs     |   3 +-
 .../Options/GeneralOptionsControl.xaml        |  12 +-
 .../ViewModels/GeneralOptionsViewModel.cs     |  17 +-
 .../ChatLoggedBasicTests.cs                   |   1 +
 .../ChatNotLoggedStateTests.cs                |   1 +
 .../Cody.VisualStudio.Tests.csproj            |   3 +
 .../ConsoleApp1/ConsoleApp1/Manager.cs        |  19 +-
 src/Cody.VisualStudio.Tests/TestsBase.cs      |  12 +-
 src/Cody.VisualStudio/Client/AgentClient.cs   |  11 +-
 .../Client/AgentJsonMessageFormatter.cs       |  33 ---
 src/Cody.VisualStudio/Client/TraceJsonRpc.cs  |  24 ++
 .../Cody.VisualStudio.csproj                  |  11 +-
 src/Cody.VisualStudio/CodyPackage.cs          |   7 +-
 .../Completions/CodyProposalCollection.cs     |  13 +
 .../Completions/CodyProposalManager.cs        |  38 +++
 .../CodyProposalManagerProvider.cs            |  27 ++
 .../Completions/CodyProposalSource.cs         | 279 ++++++++++++++++++
 .../Completions/CodyProposalSourceProvider.cs | 124 ++++++++
 .../Options/GeneralOptionsPage.cs             |  14 +-
 .../Services/DocumentsSyncService.cs          | 103 ++++---
 .../Services/TestingSupportService.cs         |  58 ++++
 .../source.extension.vsixmanifest             |   1 +
 40 files changed, 908 insertions(+), 117 deletions(-)
 create mode 100644 src/Cody.Core/Agent/Protocol/AutocompleteItem.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/AutocompleteParams.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/AutocompleteResult.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/CompletionBookkeepingEvent.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/CompletionItemInfo.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/CompletionItemParams.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/GetDocumentsParams.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/GetDocumentsResult.cs
 create mode 100644 src/Cody.Core/Agent/Protocol/SelectedCompletionInfo.cs
 create mode 100644 src/Cody.Core/Common/StringExtensions.cs
 delete mode 100644 src/Cody.VisualStudio/Client/AgentJsonMessageFormatter.cs
 create mode 100644 src/Cody.VisualStudio/Client/TraceJsonRpc.cs
 create mode 100644 src/Cody.VisualStudio/Completions/CodyProposalCollection.cs
 create mode 100644 src/Cody.VisualStudio/Completions/CodyProposalManager.cs
 create mode 100644 src/Cody.VisualStudio/Completions/CodyProposalManagerProvider.cs
 create mode 100644 src/Cody.VisualStudio/Completions/CodyProposalSource.cs
 create mode 100644 src/Cody.VisualStudio/Completions/CodyProposalSourceProvider.cs
 create mode 100644 src/Cody.VisualStudio/Services/TestingSupportService.cs

diff --git a/agent/agent.version b/agent/agent.version
index af21dcc1..eb9b96da 100644
--- a/agent/agent.version
+++ b/agent/agent.version
@@ -1 +1 @@
-vscode-v1.54.x
\ No newline at end of file
+vscode-v1.54.0
\ No newline at end of file
diff --git a/src/Cody.Core/Agent/IAgentService.cs b/src/Cody.Core/Agent/IAgentService.cs
index 717cb74a..eaf410cb 100644
--- a/src/Cody.Core/Agent/IAgentService.cs
+++ b/src/Cody.Core/Agent/IAgentService.cs
@@ -1,6 +1,7 @@
 using Cody.Core.Agent.Protocol;
-using System.Collections.Generic;
 using System;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace Cody.Core.Agent
@@ -61,6 +62,21 @@ public interface IAgentService
         [AgentCall("progress/cancel")]
         void CancelProgress(string id);
 
+        [AgentCall("autocomplete/execute")]
+        Task<AutocompleteResult> Autocomplete(AutocompleteParams autocomplete, CancellationToken cancellationToken);
+
+        [AgentCall("autocomplete/clearLastCandidate")]
+        void ClearLastCandidate();
+
+        [AgentCall("autocomplete/completionSuggested")]
+        void CompletionSuggested(CompletionItemParams completionItem);
+
+        [AgentCall("autocomplete/completionAccepted")]
+        void CompletionAccepted(CompletionItemParams completionItem);
+
+        [AgentCall("testing/workspaceDocuments")]
+        Task<GetDocumentsResult> GetWorkspaceDocuments(GetDocumentsParams documents);
+
         //---------------------------------------------------------
         // For notifications return type MUST be void!
         //---------------------------------------------------------
diff --git a/src/Cody.Core/Agent/NotificationHandlers.cs b/src/Cody.Core/Agent/NotificationHandlers.cs
index 392c678d..d7465786 100644
--- a/src/Cody.Core/Agent/NotificationHandlers.cs
+++ b/src/Cody.Core/Agent/NotificationHandlers.cs
@@ -2,6 +2,7 @@
 using Cody.Core.Infrastructure;
 using Cody.Core.Logging;
 using Cody.Core.Settings;
+using Cody.Core.Trace;
 using Cody.Core.Workspace;
 using Newtonsoft.Json.Linq;
 using System;
@@ -11,6 +12,8 @@ namespace Cody.Core.Agent
 {
     public class NotificationHandlers : INotificationHandler
     {
+        private static TraceLogger trace = new TraceLogger(nameof(NotificationHandlers));
+
         private readonly WebviewMessageHandler _messageFilter;
         private readonly IUserSettingsService _settingsService;
         private readonly IFileService _fileService;
@@ -57,9 +60,10 @@ await agentClient.ReceiveMessageStringEncoded(new ReceiveMessageStringEncodedPar
         }
 
         [AgentCallback("debug/message")]
-        public void Debug(string channel, string message)
+        public void Debug(string channel, string message, string level)
         {
-            _logger.Debug($"[{channel} {message}]");
+            //_logger.Debug($"[{channel} {message}]");
+            trace.TraceEvent("AgentDebug", message);
         }
 
         [AgentCallback("webview/registerWebview")]
diff --git a/src/Cody.Core/Agent/Protocol/AutocompleteItem.cs b/src/Cody.Core/Agent/Protocol/AutocompleteItem.cs
new file mode 100644
index 00000000..77785dce
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/AutocompleteItem.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class AutocompleteItem
+    {
+        public string Id { get; set; }
+        public string InsertText { get; set; }
+        public Range Range { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/AutocompleteParams.cs b/src/Cody.Core/Agent/Protocol/AutocompleteParams.cs
new file mode 100644
index 00000000..866b5354
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/AutocompleteParams.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class AutocompleteParams
+    {
+        public string Uri { get; set; }
+        public string FilePath { get; set; }
+
+        public Position Position { get; set; }
+
+        public TriggerKind? TriggerKind { get; set; }
+
+        public SelectedCompletionInfo SelectedCompletionInfo { get; set; }
+    }
+
+    public enum TriggerKind
+    {
+        [EnumMember(Value = nameof(Automatic))] //overwrites default camelCase naming convention
+        Automatic,
+
+        [EnumMember(Value = nameof(Invoke))]
+        Invoke
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/AutocompleteResult.cs b/src/Cody.Core/Agent/Protocol/AutocompleteResult.cs
new file mode 100644
index 00000000..9e13305b
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/AutocompleteResult.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class AutocompleteResult
+    {
+        public AutocompleteItem[] Items { get; set; }
+
+        public CompletionBookkeepingEvent CompletionEvent { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/CompletionBookkeepingEvent.cs b/src/Cody.Core/Agent/Protocol/CompletionBookkeepingEvent.cs
new file mode 100644
index 00000000..0bedbbe3
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/CompletionBookkeepingEvent.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class CompletionBookkeepingEvent
+    {
+        public CompletionItemInfo[] Items { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/CompletionItemInfo.cs b/src/Cody.Core/Agent/Protocol/CompletionItemInfo.cs
new file mode 100644
index 00000000..7080b29d
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/CompletionItemInfo.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class CompletionItemInfo
+    {
+        public int LineCount { get; set; }
+        public int CharCount { get; set; }
+
+        public string InsertText { get; set; }
+
+        public string StopReason { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/CompletionItemParams.cs b/src/Cody.Core/Agent/Protocol/CompletionItemParams.cs
new file mode 100644
index 00000000..f57fcd4a
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/CompletionItemParams.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class CompletionItemParams
+    {
+        public string CompletionID { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/GetDocumentsParams.cs b/src/Cody.Core/Agent/Protocol/GetDocumentsParams.cs
new file mode 100644
index 00000000..d289e4ae
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/GetDocumentsParams.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class GetDocumentsParams
+    {
+        public string[] Uris { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/GetDocumentsResult.cs b/src/Cody.Core/Agent/Protocol/GetDocumentsResult.cs
new file mode 100644
index 00000000..291831f4
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/GetDocumentsResult.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class GetDocumentsResult
+    {
+        public ProtocolTextDocument[] Documents { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Agent/Protocol/SelectedCompletionInfo.cs b/src/Cody.Core/Agent/Protocol/SelectedCompletionInfo.cs
new file mode 100644
index 00000000..39890864
--- /dev/null
+++ b/src/Cody.Core/Agent/Protocol/SelectedCompletionInfo.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace Cody.Core.Agent.Protocol
+{
+    public class SelectedCompletionInfo
+    {
+        public Range Range { get; set; }
+
+        public string Text { get; set; }
+    }
+}
diff --git a/src/Cody.Core/Cody.Core.csproj b/src/Cody.Core/Cody.Core.csproj
index 545e0acb..8647a044 100644
--- a/src/Cody.Core/Cody.Core.csproj
+++ b/src/Cody.Core/Cody.Core.csproj
@@ -38,6 +38,7 @@
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
     <Reference Include="System.Numerics" />
+    <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -54,11 +55,20 @@
     <Compile Include="Agent\NotificationHandlers.cs" />
     <Compile Include="Agent\ProgressNotificationHandlers.cs" />
     <Compile Include="Agent\Protocol\AuthStatus.cs" />
+    <Compile Include="Agent\Protocol\AutocompleteItem.cs" />
+    <Compile Include="Agent\Protocol\AutocompleteParams.cs" />
+    <Compile Include="Agent\Protocol\AutocompleteResult.cs" />
     <Compile Include="Agent\Protocol\ChatPanelInfo.cs" />
+    <Compile Include="Agent\Protocol\CompletionBookkeepingEvent.cs" />
+    <Compile Include="Agent\Protocol\CompletionItemInfo.cs" />
+    <Compile Include="Agent\Protocol\CompletionItemParams.cs" />
+    <Compile Include="Agent\Protocol\GetDocumentsParams.cs" />
+    <Compile Include="Agent\Protocol\GetDocumentsResult.cs" />
     <Compile Include="Agent\Protocol\ProgressOptions.cs" />
     <Compile Include="Agent\Protocol\ProgressReportParams.cs" />
     <Compile Include="Agent\Protocol\ProgressStartParams.cs" />
     <Compile Include="Agent\Protocol\SaveDialogOptionsParams.cs" />
+    <Compile Include="Agent\Protocol\SelectedCompletionInfo.cs" />
     <Compile Include="Agent\Protocol\TestProgress.cs" />
     <Compile Include="Agent\Protocol\WorkspaceFolderDidChangeEvent.cs" />
     <Compile Include="Agent\Protocol\TextDocumentShowParamsOptions.cs" />
@@ -81,6 +91,7 @@
     <Compile Include="Agent\Protocol\ResolveWebviewViewParams.cs" />
     <Compile Include="Agent\SetHtmlEvent.cs" />
     <Compile Include="Agent\WebviewMessageHandler.cs" />
+    <Compile Include="Common\StringExtensions.cs" />
     <Compile Include="Common\Configuration.cs" />
     <Compile Include="Common\Configuration.Setup.cs" />
     <Compile Include="DocumentSync\DocumentSyncCallback.cs" />
diff --git a/src/Cody.Core/Common/StringExtensions.cs b/src/Cody.Core/Common/StringExtensions.cs
new file mode 100644
index 00000000..64dd8efe
--- /dev/null
+++ b/src/Cody.Core/Common/StringExtensions.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Cody.Core.Common
+{
+    public static class StringExtensions
+    {
+        public static string ToUri(this string path)
+        {
+            var uri = new Uri(path).AbsoluteUri;
+            return Regex.Replace(uri, "(file:///)(\\D+)(:)", m => m.Groups[1].Value + m.Groups[2].Value.ToLower() + "%3A");
+        }
+
+        public static string ConvertLineBreaks(this string text, string lineBrakeChars)
+        {
+            return Regex.Replace(text, @"\r\n?|\n", lineBrakeChars);
+        }
+    }
+}
diff --git a/src/Cody.Core/DocumentSync/DocumentSyncCallback.cs b/src/Cody.Core/DocumentSync/DocumentSyncCallback.cs
index 97e5c02e..84df61ac 100644
--- a/src/Cody.Core/DocumentSync/DocumentSyncCallback.cs
+++ b/src/Cody.Core/DocumentSync/DocumentSyncCallback.cs
@@ -1,11 +1,11 @@
 using Cody.Core.Agent;
 using Cody.Core.Agent.Protocol;
+using Cody.Core.Common;
 using Cody.Core.Logging;
 using Cody.Core.Trace;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.RegularExpressions;
 
 namespace Cody.Core.DocumentSync
 {
@@ -22,12 +22,6 @@ public DocumentSyncCallback(IAgentService agentService, ILog logger)
             this.logger = logger;
         }
 
-        private string ToUri(string path)
-        {
-            var uri = new Uri(path).AbsoluteUri;
-            return Regex.Replace(uri, "(file:///)(\\D+)(:)", m => m.Groups[1].Value + m.Groups[2].Value.ToLower() + "%3A");
-        }
-
         public void OnChanged(string fullPath, DocumentRange visibleRange, DocumentRange selection, IEnumerable<DocumentChange> changes)
         {
             trace.TraceEvent("DidChange", "ch: '{0}', sel:{1}, vr:{2}, path:{3}", string.Join("", changes), selection, visibleRange, fullPath);
@@ -52,7 +46,7 @@ public void OnChanged(string fullPath, DocumentRange visibleRange, DocumentRange
 
             var docState = new ProtocolTextDocument
             {
-                Uri = ToUri(fullPath),
+                Uri = fullPath.ToUri(),
                 VisibleRange = vRange,
                 Selection = new Range
                 {
@@ -69,7 +63,7 @@ public void OnChanged(string fullPath, DocumentRange visibleRange, DocumentRange
                 },
                 ContentChanges = changes.Select(x => new ProtocolTextDocumentContentChangeEvent
                 {
-                    Text = x.Text,
+                    Text = x.Text.ConvertLineBreaks("\n"),
                     Range = new Range
                     {
                         Start = new Position
@@ -87,6 +81,8 @@ public void OnChanged(string fullPath, DocumentRange visibleRange, DocumentRange
             };
 
             agentService.DidChange(docState);
+            //var result = agentService.GetWorkspaceDocuments(new GetDocumentsParams { Uris = new[] { fullPath.ToUri() } }).Result;
+            //trace.TraceEvent("AfterDidChange", result.Documents.First().Content);
         }
 
         public void OnClosed(string fullPath)
@@ -95,7 +91,7 @@ public void OnClosed(string fullPath)
 
             var docState = new ProtocolTextDocument
             {
-                Uri = ToUri(fullPath),
+                Uri = fullPath.ToUri(),
             };
 
             // Only the 'uri' property is required, other properties are ignored.
@@ -105,7 +101,7 @@ public void OnClosed(string fullPath)
         public void OnFocus(string fullPath)
         {
             trace.TraceEvent("DidFocus", "{0}", fullPath);
-            agentService.DidFocus(new CodyFilePath { Uri = ToUri(fullPath) });
+            agentService.DidFocus(new CodyFilePath { Uri = fullPath.ToUri() });
         }
 
         public void OnOpened(string fullPath, string content, DocumentRange visibleRange, DocumentRange selection)
@@ -132,8 +128,8 @@ public void OnOpened(string fullPath, string content, DocumentRange visibleRange
 
             var docState = new ProtocolTextDocument
             {
-                Uri = ToUri(fullPath),
-                Content = content,
+                Uri = fullPath.ToUri(),
+                Content = content.ConvertLineBreaks("\n"),
                 VisibleRange = vRange,
                 Selection = new Range
                 {
@@ -156,7 +152,7 @@ public void OnOpened(string fullPath, string content, DocumentRange visibleRange
         public void OnSaved(string fullPath)
         {
             trace.TraceEvent("DidSave", "{0}", fullPath);
-            agentService.DidSave(new CodyFilePath { Uri = ToUri(fullPath) });
+            agentService.DidSave(new CodyFilePath { Uri = fullPath.ToUri() });
         }
     }
 }
diff --git a/src/Cody.Core/Settings/IUserSettingsService.cs b/src/Cody.Core/Settings/IUserSettingsService.cs
index f629682b..ad8125ae 100644
--- a/src/Cody.Core/Settings/IUserSettingsService.cs
+++ b/src/Cody.Core/Settings/IUserSettingsService.cs
@@ -10,6 +10,7 @@ public interface IUserSettingsService
         string ServerEndpoint { get; set; }
         string CustomConfiguration { get; set; }
         bool AcceptNonTrustedCert { get; set; }
+        bool AutomaticallyTriggerCompletions { get; set; }
 
 
         event EventHandler AuthorizationDetailsChanged;
diff --git a/src/Cody.Core/Settings/UserSettingsService.cs b/src/Cody.Core/Settings/UserSettingsService.cs
index 09d2b136..8d0e1c33 100644
--- a/src/Cody.Core/Settings/UserSettingsService.cs
+++ b/src/Cody.Core/Settings/UserSettingsService.cs
@@ -110,5 +110,15 @@ public bool AcceptNonTrustedCert
             }
             set => Set(nameof(AcceptNonTrustedCert), value.ToString());
         }
+
+        public bool AutomaticallyTriggerCompletions
+        {
+            get
+            {
+                var value = GetOrDefault(nameof(AutomaticallyTriggerCompletions), true.ToString());
+                return bool.Parse(value);
+            }
+            set => Set(nameof(AutomaticallyTriggerCompletions), value.ToString());
+        }
     }
 }
diff --git a/src/Cody.Core/Trace/FileTraceListener.cs b/src/Cody.Core/Trace/FileTraceListener.cs
index 506fcf3f..74343f43 100644
--- a/src/Cody.Core/Trace/FileTraceListener.cs
+++ b/src/Cody.Core/Trace/FileTraceListener.cs
@@ -34,7 +34,8 @@ protected string FormatTraceEvent(TraceEvent traceEvent)
 
             if (!string.IsNullOrEmpty(traceEvent.Message))
             {
-                sb.AppendFormat(traceEvent.Message, traceEvent.MessageArgs);
+                if (traceEvent.MessageArgs != null && traceEvent.MessageArgs.Any()) sb.AppendFormat(traceEvent.Message, traceEvent.MessageArgs);
+                else sb.Append(traceEvent.Message);
             }
 
             if (traceEvent.Data != null)
diff --git a/src/Cody.Core/Trace/LogioTraceListener.cs b/src/Cody.Core/Trace/LogioTraceListener.cs
index fe6c303f..a3a43e9e 100644
--- a/src/Cody.Core/Trace/LogioTraceListener.cs
+++ b/src/Cody.Core/Trace/LogioTraceListener.cs
@@ -49,7 +49,8 @@ protected override void Write(TraceEvent traceEvent)
             if (!string.IsNullOrEmpty(traceEvent.Message))
             {
                 sb.Append(" ");
-                sb.AppendFormat(traceEvent.Message, traceEvent.MessageArgs);
+                if (traceEvent.MessageArgs != null && traceEvent.MessageArgs.Any()) sb.AppendFormat(traceEvent.Message, traceEvent.MessageArgs);
+                else sb.Append(traceEvent.Message);
             }
 
             if (traceEvent.Data != null)
diff --git a/src/Cody.UI/Controls/Options/GeneralOptionsControl.xaml b/src/Cody.UI/Controls/Options/GeneralOptionsControl.xaml
index d383d98e..d1bae16f 100644
--- a/src/Cody.UI/Controls/Options/GeneralOptionsControl.xaml
+++ b/src/Cody.UI/Controls/Options/GeneralOptionsControl.xaml
@@ -17,6 +17,7 @@
                     <RowDefinition Height="Auto" />
                     <RowDefinition Height="Auto" />
                     <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
                 </Grid.RowDefinitions>
 
                 <Grid.ColumnDefinitions>
@@ -60,10 +61,19 @@
                     Content="Accept non-trusted certificates (requires restart)"
                  />
 
+                <CheckBox
+                    Name="AutomaticallyTriggerCompletionsCheckBox"
+                    Grid.Row="3"
+                    Grid.Column="1"
+                    Margin="0 5 0 0"
+                    IsChecked="{Binding AutomaticallyTriggerCompletions, Mode=TwoWay}"
+                    Content="Automatically trigger completions"
+                 />
+
                 <!--Get Help-->
                 <Button 
                     Margin="0 5 0 0"
-                    Grid.Row="3"
+                    Grid.Row="4"
                     Grid.Column="1"
                     Height="25"
                     Width="100"
diff --git a/src/Cody.UI/ViewModels/GeneralOptionsViewModel.cs b/src/Cody.UI/ViewModels/GeneralOptionsViewModel.cs
index 31d03d33..079a7f31 100644
--- a/src/Cody.UI/ViewModels/GeneralOptionsViewModel.cs
+++ b/src/Cody.UI/ViewModels/GeneralOptionsViewModel.cs
@@ -1,7 +1,7 @@
-using System;
-using System.Diagnostics;
 using Cody.Core.Logging;
 using Cody.UI.MVVM;
+using System;
+using System.Diagnostics;
 
 namespace Cody.UI.ViewModels
 {
@@ -65,5 +65,18 @@ public bool AcceptNonTrustedCert
             }
         }
 
+        private bool _automaticallyTriggerCompletions;
+        public bool AutomaticallyTriggerCompletions
+        {
+            get => _automaticallyTriggerCompletions;
+            set
+            {
+                if (SetProperty(ref _automaticallyTriggerCompletions, value))
+                {
+                    _logger.Debug($"AutomaticallyTriggerCompletions set:{value}");
+                }
+            }
+        }
+
     }
 }
diff --git a/src/Cody.VisualStudio.Tests/ChatLoggedBasicTests.cs b/src/Cody.VisualStudio.Tests/ChatLoggedBasicTests.cs
index 2e59ef42..703a921b 100644
--- a/src/Cody.VisualStudio.Tests/ChatLoggedBasicTests.cs
+++ b/src/Cody.VisualStudio.Tests/ChatLoggedBasicTests.cs
@@ -30,6 +30,7 @@ public async Task Solution_Name_Is_Added_To_Chat_Input()
             await OpenSolution(SolutionsPaths.GetConsoleApp1File("ConsoleApp1.sln"));
 
             // when
+            await ShowChatTab();
             var tags = await GetChatContextTags();
 
             // then
diff --git a/src/Cody.VisualStudio.Tests/ChatNotLoggedStateTests.cs b/src/Cody.VisualStudio.Tests/ChatNotLoggedStateTests.cs
index 125b0492..3eab1538 100644
--- a/src/Cody.VisualStudio.Tests/ChatNotLoggedStateTests.cs
+++ b/src/Cody.VisualStudio.Tests/ChatNotLoggedStateTests.cs
@@ -77,6 +77,7 @@ private async Task NotInLoggedState(Func<Task> action)
             finally
             {
                 await RevertToken();
+                await Task.Delay(1000);
             }
         }
 
diff --git a/src/Cody.VisualStudio.Tests/Cody.VisualStudio.Tests.csproj b/src/Cody.VisualStudio.Tests/Cody.VisualStudio.Tests.csproj
index 390fd3f7..4c8a591c 100644
--- a/src/Cody.VisualStudio.Tests/Cody.VisualStudio.Tests.csproj
+++ b/src/Cody.VisualStudio.Tests/Cody.VisualStudio.Tests.csproj
@@ -75,6 +75,9 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="InputSimulatorPlus">
+      <Version>1.0.7</Version>
+    </PackageReference>
     <PackageReference Include="Microsoft.Playwright">
       <Version>1.45.0</Version>
     </PackageReference>
diff --git a/src/Cody.VisualStudio.Tests/TestProjects/ConsoleApp1/ConsoleApp1/Manager.cs b/src/Cody.VisualStudio.Tests/TestProjects/ConsoleApp1/ConsoleApp1/Manager.cs
index 31b8e0c3..6beadfa1 100644
--- a/src/Cody.VisualStudio.Tests/TestProjects/ConsoleApp1/ConsoleApp1/Manager.cs
+++ b/src/Cody.VisualStudio.Tests/TestProjects/ConsoleApp1/ConsoleApp1/Manager.cs
@@ -3,4 +3,21 @@ namespace ConsoleApp1;
 public class Manager2
 {
     public Manager2() { }
-}
\ No newline at end of file
+
+    public void Print()
+    {
+        Console.WriteLine("Hello, World!");
+
+        Console.WriteLine("Bye, World!");
+
+    }
+
+
+    private void PrintRepeated(int repeat, string text)
+    {
+        if (repeat < 0) throw new ArgumentException("repeat must be greater than 0");
+
+    }
+
+    private void ExitApp(int exit) => Environment.Exit(exit);
+}
diff --git a/src/Cody.VisualStudio.Tests/TestsBase.cs b/src/Cody.VisualStudio.Tests/TestsBase.cs
index 0ef05a19..1f541129 100644
--- a/src/Cody.VisualStudio.Tests/TestsBase.cs
+++ b/src/Cody.VisualStudio.Tests/TestsBase.cs
@@ -13,6 +13,7 @@
 using Xunit.Abstractions;
 using System.Diagnostics;
 using Thread = System.Threading.Thread;
+using Microsoft.VisualStudio.Shell.Events;
 
 namespace Cody.VisualStudio.Tests
 {
@@ -79,12 +80,15 @@ protected void TakeScreenshot(string name)
 
         protected async Task OpenSolution(string path)
         {
+            var tcs = new TaskCompletionSource<bool>();
+            EventHandler handler = (sender, e) => tcs.TrySetResult(true);
+            SolutionEvents.OnAfterBackgroundSolutionLoadComplete += handler;
 
             WriteLog($"Opening solution '{path}' ...");
             Dte.Solution.Open(path);
 
-            await Task.Delay(TimeSpan.FromSeconds(5));
-            WriteLog("Delay after solution open stopped.");
+            await tcs.Task;
+            SolutionEvents.OnAfterBackgroundSolutionLoadComplete -= handler;
         }
 
         protected void CloseSolution() => Dte.Solution.Close();
@@ -160,13 +164,13 @@ protected async Task WaitForAsync(Func<bool> condition)
             {
                 await Task.Delay(TimeSpan.FromSeconds(1));
 
-                WriteLog("Chat not loaded ...");
+                WriteLog("Waiting ...");
 
                 var nowTime = DateTime.Now;
                 var currentSpan = nowTime - startTime;
                 if (currentSpan >= timeout)
                 {
-                    var message = $"Chat timeout! It's loading for more than {currentSpan.TotalSeconds} s.";
+                    var message = $"Timeout! It's waiting for more than {currentSpan.TotalSeconds} s.";
                     WriteLog(message);
                     throw new Exception(message);
                 }
diff --git a/src/Cody.VisualStudio/Client/AgentClient.cs b/src/Cody.VisualStudio/Client/AgentClient.cs
index 8498b340..0d8e70de 100644
--- a/src/Cody.VisualStudio/Client/AgentClient.cs
+++ b/src/Cody.VisualStudio/Client/AgentClient.cs
@@ -1,6 +1,7 @@
 using Cody.Core.Agent;
 using Cody.Core.Agent.Protocol;
 using Cody.Core.Logging;
+using Cody.Core.Trace;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 using StreamJsonRpc;
@@ -11,6 +12,8 @@ namespace Cody.VisualStudio.Client
 {
     public class AgentClient : IAgentProxy
     {
+        private static TraceLogger trace = new TraceLogger(nameof(AgentClient));
+
         private AgentClientOptions options;
         private ILog log;
         private ILog agentLog;
@@ -40,8 +43,7 @@ public void Start()
 
             connector.Connect(options);
 
-            var jsonMessageFormatter = new AgentJsonMessageFormatter(agentLog);
-            jsonMessageFormatter.TraceSentMessages = options.Debug;
+            var jsonMessageFormatter = new JsonMessageFormatter();
             jsonMessageFormatter.JsonSerializer.ContractResolver = new DefaultContractResolver()
             {
                 NamingStrategy = new CamelCaseNamingStrategy()
@@ -49,7 +51,7 @@ public void Start()
             jsonMessageFormatter.JsonSerializer.Converters.Add(new StringEnumConverter(new CamelCaseNamingStrategy()));
             var handler = new HeaderDelimitedMessageHandler(connector.SendingStream, connector.ReceivingStream, jsonMessageFormatter);
 
-            jsonRpc = new JsonRpc(handler);
+            jsonRpc = new TraceJsonRpc(handler);
             jsonRpc.Disconnected += OnDisconnected;
 
             foreach (var target in options.CallbackHandlers)
@@ -93,7 +95,8 @@ private void CreateAgentService()
 
         private void OnErrorReceived(object sender, string error)
         {
-            agentLog.Debug(error);
+            //agentLog.Debug(error);
+            trace.TraceEvent("AgentErrorOutput", error);
         }
 
         private IAgentConnector CreateConnector()
diff --git a/src/Cody.VisualStudio/Client/AgentJsonMessageFormatter.cs b/src/Cody.VisualStudio/Client/AgentJsonMessageFormatter.cs
deleted file mode 100644
index 90b03a31..00000000
--- a/src/Cody.VisualStudio/Client/AgentJsonMessageFormatter.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using Cody.Core.Logging;
-using StreamJsonRpc;
-using StreamJsonRpc.Protocol;
-using StreamJsonRpc.Reflection;
-using System;
-using System.Buffers;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Cody.VisualStudio.Client
-{
-    internal class AgentJsonMessageFormatter : JsonMessageFormatter, IJsonRpcFormatterTracingCallbacks
-    {
-        private ILog log;
-
-        public AgentJsonMessageFormatter(ILog log)
-        {
-            this.log = log;
-        }
-
-        public bool TraceSentMessages { get; set; }
-
-        public void OnSerializationComplete(JsonRpcMessage message, ReadOnlySequence<byte> encodedMessage)
-        {
-            if (TraceSentMessages)
-            {
-                string result = Encoding.UTF8.GetString(encodedMessage.ToArray());
-                log.Debug($"Sending to agent: {result}");
-            }
-        }
-    }
-}
diff --git a/src/Cody.VisualStudio/Client/TraceJsonRpc.cs b/src/Cody.VisualStudio/Client/TraceJsonRpc.cs
new file mode 100644
index 00000000..3c74ec53
--- /dev/null
+++ b/src/Cody.VisualStudio/Client/TraceJsonRpc.cs
@@ -0,0 +1,24 @@
+using Cody.Core.Trace;
+using StreamJsonRpc;
+using StreamJsonRpc.Protocol;
+using StreamJsonRpc.Reflection;
+
+namespace Cody.VisualStudio.Client
+{
+    public class TraceJsonRpc : JsonRpc, IJsonRpcTracingCallbacks
+    {
+        private static readonly TraceLogger trace = new TraceLogger(nameof(TraceJsonRpc));
+
+        public TraceJsonRpc(IJsonRpcMessageHandler messageHandler) : base(messageHandler) { }
+
+        void IJsonRpcTracingCallbacks.OnMessageSerialized(JsonRpcMessage message, object encodedMessage)
+        {
+            trace.TraceEvent("ToAgent", encodedMessage);
+        }
+
+        void IJsonRpcTracingCallbacks.OnMessageDeserialized(JsonRpcMessage message, object encodedMessage)
+        {
+            trace.TraceEvent("FromAgent", encodedMessage);
+        }
+    }
+}
diff --git a/src/Cody.VisualStudio/Cody.VisualStudio.csproj b/src/Cody.VisualStudio/Cody.VisualStudio.csproj
index d485df0f..a31f3a9d 100644
--- a/src/Cody.VisualStudio/Cody.VisualStudio.csproj
+++ b/src/Cody.VisualStudio/Cody.VisualStudio.csproj
@@ -48,13 +48,18 @@
   <ItemGroup>
     <Compile Include="Client\AgentClient.cs" />
     <Compile Include="Client\AgentClientOptions.cs" />
-    <Compile Include="Client\AgentJsonMessageFormatter.cs" />
     <Compile Include="Client\AgentProcessConnector.cs" />
     <Compile Include="Client\IAgentConnector.cs" />
     <Compile Include="Client\NameTransformer.cs" />
     <Compile Include="Client\RemoteAgentConnector.cs" />
+    <Compile Include="Client\TraceJsonRpc.cs" />
     <Compile Include="CodyPackage.ErrorHandling.cs" />
     <Compile Include="CodyToolWindow.cs" />
+    <Compile Include="Completions\CodyProposalCollection.cs" />
+    <Compile Include="Completions\CodyProposalManager.cs" />
+    <Compile Include="Completions\CodyProposalManagerProvider.cs" />
+    <Compile Include="Completions\CodyProposalSource.cs" />
+    <Compile Include="Completions\CodyProposalSourceProvider.cs" />
     <Compile Include="Infrastructure\LoggerFactory.cs" />
     <Compile Include="Infrastructure\WindowPaneLogger.cs" />
     <Compile Include="Infrastructure\VsConstants.cs" />
@@ -73,6 +78,7 @@
     </Compile>
     <Compile Include="Services\ProgressService.cs" />
     <Compile Include="Services\SolutionService.cs" />
+    <Compile Include="Services\TestingSupportService.cs" />
     <Compile Include="Services\ThemeService.cs" />
     <Compile Include="Services\StatusbarService.cs" />
     <Compile Include="Services\UserSettingsProvider.cs" />
@@ -118,6 +124,9 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.Language">
+      <Version>17.11.260</Version>
+    </PackageReference>
     <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.0.0-previews-4-31709-430" ExcludeAssets="runtime" />
     <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="17.6.2164">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/src/Cody.VisualStudio/CodyPackage.cs b/src/Cody.VisualStudio/CodyPackage.cs
index f8ab64ee..3cbf728c 100644
--- a/src/Cody.VisualStudio/CodyPackage.cs
+++ b/src/Cody.VisualStudio/CodyPackage.cs
@@ -55,10 +55,10 @@ public sealed partial class CodyPackage : AsyncPackage
         public ILog AgentLogger;
         public ILog AgentNotificationsLogger;
 
+        public static IAgentService AgentService;
+        public static IUserSettingsService UserSettingsService;
         public IVersionService VersionService;
         public IVsVersionService VsVersionService;
-        public IAgentService AgentService;
-        public IUserSettingsService UserSettingsService;
         public IStatusbarService StatusbarService;
         public IThemeService ThemeService;
         public ISolutionService SolutionService;
@@ -75,6 +75,7 @@ public sealed partial class CodyPackage : AsyncPackage
         public NotificationHandlers NotificationHandlers;
         public ProgressNotificationHandlers ProgressNotificationHandlers;
         public DocumentsSyncService DocumentsSyncService;
+        public static TestingSupportService TestingSupportService;
         public IFileService FileService;
         public IVsUIShell VsUIShell;
         public IVsEditorAdaptersFactoryService VsEditorAdaptersFactoryService;
@@ -127,6 +128,8 @@ private void InitializeServices()
             FileService = new FileService(this, Logger);
             var statusCenterService = this.GetService<SVsTaskStatusCenterService, IVsTaskStatusCenterService>();
             ProgressService = new ProgressService(statusCenterService);
+            TestingSupportService = null; // new TestingSupportService(statusCenterService);
+
             NotificationHandlers = new NotificationHandlers(UserSettingsService, AgentNotificationsLogger, FileService, SecretStorageService);
             NotificationHandlers.OnOptionsPageShowRequest += HandleOnOptionsPageShowRequest;
             NotificationHandlers.OnFocusSidebarRequest += HandleOnFocusSidebarRequest;
diff --git a/src/Cody.VisualStudio/Completions/CodyProposalCollection.cs b/src/Cody.VisualStudio/Completions/CodyProposalCollection.cs
new file mode 100644
index 00000000..b4d9140a
--- /dev/null
+++ b/src/Cody.VisualStudio/Completions/CodyProposalCollection.cs
@@ -0,0 +1,13 @@
+using Microsoft.VisualStudio.Language.Proposals;
+using System;
+using System.Collections.Generic;
+
+namespace Cody.VisualStudio.Completions
+{
+    public class CodyProposalCollection : ProposalCollection
+    {
+        public CodyProposalCollection(IReadOnlyList<ProposalBase> proposals) : base(nameof(CodyProposalSource), proposals)
+        {
+        }
+    }
+}
diff --git a/src/Cody.VisualStudio/Completions/CodyProposalManager.cs b/src/Cody.VisualStudio/Completions/CodyProposalManager.cs
new file mode 100644
index 00000000..76f7d290
--- /dev/null
+++ b/src/Cody.VisualStudio/Completions/CodyProposalManager.cs
@@ -0,0 +1,38 @@
+using Cody.Core.Trace;
+using Microsoft.VisualStudio.Language.Proposals;
+using Microsoft.VisualStudio.Text;
+
+namespace Cody.VisualStudio.Completions
+{
+    public class CodyProposalManager : ProposalManagerBase
+    {
+        private static TraceLogger trace = new TraceLogger(nameof(CodyProposalManager));
+
+        public override bool TryGetIsProposalPosition(VirtualSnapshotPoint caret, ProposalScenario scenario, char triggerCharacter, ref bool value)
+        {
+            switch (scenario)
+            {
+                case ProposalScenario.TypeChar:
+                    trace.TraceEvent("TypeCharScenario");
+                    if (char.IsWhiteSpace(triggerCharacter) && caret.Position.Position >= 2)
+                    {
+                        char c = caret.Position.Snapshot[caret.Position.Position - 2];
+                        if (!char.IsWhiteSpace(c)) value = true;
+                    }
+                    else value = true;
+                    break;
+                case ProposalScenario.Return:
+                    trace.TraceEvent("ReturnScenario");
+                    if (caret.Position.GetContainingLine().End == caret.Position) value = true;
+                    break;
+                default:
+                    trace.TraceEvent("OtherScenario");
+                    value = true;
+                    break;
+            }
+
+            trace.TraceEvent("ShowProposal", value);
+            return value;
+        }
+    }
+}
diff --git a/src/Cody.VisualStudio/Completions/CodyProposalManagerProvider.cs b/src/Cody.VisualStudio/Completions/CodyProposalManagerProvider.cs
new file mode 100644
index 00000000..1ffcdc5e
--- /dev/null
+++ b/src/Cody.VisualStudio/Completions/CodyProposalManagerProvider.cs
@@ -0,0 +1,27 @@
+using Cody.Core.Trace;
+using Microsoft.VisualStudio.Language.Proposals;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+using System.ComponentModel.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Cody.VisualStudio.Completions
+{
+    [Export(typeof(ProposalManagerProviderBase))]
+    [Name(nameof(CodyProposalManagerProvider))]
+    [Order(Before = "InlineCSharpProposalManagerProvider")]
+    [Order(Before = "IntelliCodeCSharpProposalManager")]
+    [Order(Before = "Highest Priority")]
+    [ContentType("any")]
+    public class CodyProposalManagerProvider : ProposalManagerProviderBase
+    {
+        private static TraceLogger trace = new TraceLogger(nameof(CodyProposalManagerProvider));
+
+        public async override Task<ProposalManagerBase> GetProposalManagerAsync(ITextView view, CancellationToken cancel)
+        {
+            trace.TraceEvent("Enter");
+            return new CodyProposalManager();
+        }
+    }
+}
diff --git a/src/Cody.VisualStudio/Completions/CodyProposalSource.cs b/src/Cody.VisualStudio/Completions/CodyProposalSource.cs
new file mode 100644
index 00000000..ccf0adc5
--- /dev/null
+++ b/src/Cody.VisualStudio/Completions/CodyProposalSource.cs
@@ -0,0 +1,279 @@
+using Cody.Core.Agent;
+using Cody.Core.Agent.Protocol;
+using Cody.Core.Common;
+using Cody.Core.Settings;
+using Cody.Core.Trace;
+using Microsoft.VisualStudio.Language.Proposals;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Cody.VisualStudio.Completions
+{
+    public class CodyProposalSource : ProposalSourceBase
+    {
+        private static TraceLogger trace = new TraceLogger(nameof(CodyProposalSource));
+
+        private IAgentService agentService;
+        private ITextDocument textDocument;
+        private readonly ITextView view;
+        private static uint sessionCounter = 0;
+
+        private ITextSnapshot trackedSnapshot;
+
+        public CodyProposalSource(ITextDocument textDocument, ITextView view)
+        {
+            this.textDocument = textDocument;
+            this.view = view;
+            trackedSnapshot = textDocument.TextBuffer.CurrentSnapshot;
+            textDocument.TextBuffer.ChangedHighPriority += OnTextBufferChanged;
+        }
+
+        private void OnTextBufferChanged(object sender, TextContentChangedEventArgs e)
+        {
+            trackedSnapshot = e.After;
+        }
+
+        public override Task DisposeAsync()
+        {
+            textDocument.TextBuffer.ChangedHighPriority -= OnTextBufferChanged;
+            return base.DisposeAsync();
+        }
+
+        public override async Task<ProposalCollectionBase> RequestProposalsAsync(
+            VirtualSnapshotPoint caret,
+            CompletionState completionState,
+            ProposalScenario scenario,
+            char triggeringCharacter,
+            CancellationToken cancel)
+        {
+            var session = sessionCounter++;
+
+            try
+            {
+                trace.TraceEvent("Begin", "session: {0}", session);
+                trace.TraceEvent("Scenario", "session: {0}, scenario {1}", session, scenario);
+
+                agentService = CodyPackage.AgentService;
+
+                if (!ShouldDoProposals(completionState, scenario, agentService, CodyPackage.UserSettingsService))
+                {
+                    trace.TraceEvent("SkipScenario", "Skip scenario {0}", scenario);
+                    return null;
+                }
+
+                UpdateCaretAndCompletion(ref caret, ref completionState);
+
+                var caretPosition = ToLineColPosition(caret.Position);
+                var autocompleteRequest = new AutocompleteParams
+                {
+                    Uri = textDocument.FilePath.ToUri(),
+                    Position = caretPosition,
+                    TriggerKind = scenario == ProposalScenario.ExplicitInvocation ? TriggerKind.Invoke : TriggerKind.Automatic
+                };
+
+                if (completionState != null)
+                {
+                    var completionStart = ToLineColPosition(completionState.ApplicableToSpan.Start);
+                    var completionEnd = ToLineColPosition(completionState.ApplicableToSpan.End);
+                    autocompleteRequest.SelectedCompletionInfo = new SelectedCompletionInfo()
+                    {
+                        Text = completionState.SelectedItem,
+                        Range = new Range
+                        {
+                            Start = completionStart,
+                            End = completionEnd
+                        }
+                    };
+                }
+
+                trace.TraceEvent("BeforeRequest", new
+                {
+                    session,
+                    caret.Position.Position,
+                    caret = $"{caretPosition.Line}:{caretPosition.Character}",
+                    lineText = caret.Position.Snapshot.GetLineFromLineNumber(caretPosition.Line).GetText(),
+                    virtualSpaces = caret.VirtualSpaces,
+                    selectedItem = completionState?.SelectedItem,
+                    completionState?.IsSoftSelection,
+                    applicableToSpan = completionState?.ApplicableToSpan.ToString(),
+                    completionState?.IsSuggestion,
+                    completionState?.IsSnippet
+                });
+
+                var autocomplete = await GetAutocompleteItems(autocompleteRequest, session, cancel);
+
+                if (autocomplete == null || autocomplete.Items.Length == 0) trace.TraceEvent("AutocompliteResult", "session: {0}, No results", session);
+                else foreach (var item in autocomplete.Items) trace.TraceEvent("AutocompliteResult", item);
+
+                var newPosition = caret.Position.TranslateTo(textDocument.TextBuffer.CurrentSnapshot, PointTrackingMode.Positive);
+                var newText = newPosition.GetContainingLine().GetText();
+                trace.TraceEvent("AfterResponse", "session: {0}, newCaret: {1} lineText:'{2}'", session, newPosition.Position, newText);
+
+                var collection = CreateProposals(autocomplete, caret, completionState, session);
+                if (cancel.IsCancellationRequested) trace.TraceEvent("AutocompliteCanceled2", "session: {0}", session);
+
+                return collection;
+            }
+            catch (Exception ex)
+            {
+                trace.TraceException(ex);
+            }
+            finally
+            {
+                trace.TraceEvent("End", "session: {0}", session);
+            }
+
+            return null;
+        }
+
+        private bool ShouldDoProposals(CompletionState completionState, ProposalScenario scenario, IAgentService agentService, IUserSettingsService userSettings)
+        {
+            if (scenario == ProposalScenario.CaretMove ||
+                (completionState != null && (completionState.IsSnippet || completionState.IsSuggestion || completionState.IsPreprocessorDirective)))
+            {
+                trace.TraceMessage("Scenario without autocomplete");
+                return false;
+            }
+
+            if (agentService == null)
+            {
+                trace.TraceMessage("Agent service not jet ready");
+                return false;
+            }
+
+            if (userSettings != null && !userSettings.AutomaticallyTriggerCompletions && scenario != ProposalScenario.ExplicitInvocation)
+            {
+                trace.TraceMessage("Automatic triggering autocomplete disabled");
+                return false;
+            }
+
+            return true;
+        }
+
+        private void UpdateCaretAndCompletion(ref VirtualSnapshotPoint caret, ref CompletionState completionState)
+        {
+            if (trackedSnapshot == null || trackedSnapshot.Version.VersionNumber < caret.Position.Snapshot.Version.VersionNumber)
+            {
+                trace.TraceEvent("TrackinSnapshotFailed");
+            }
+
+            caret = caret.TranslateTo(trackedSnapshot);
+            if (completionState != null)
+            {
+                completionState = completionState.TranslateTo(trackedSnapshot);
+            }
+        }
+
+        private async Task<AutocompleteResult> GetAutocompleteItems(AutocompleteParams autocompleteRequest, uint session, CancellationToken cancel)
+        {
+            trace.TraceEvent("AutocompliteRequest", autocompleteRequest);
+            var stopwatch = new Stopwatch();
+
+            var autocompleteCancel = new CancellationTokenSource();
+            var autocompleteTask = agentService.Autocomplete(autocompleteRequest, autocompleteCancel.Token);
+            var cancelationTask = Task.Delay(8000, cancel);
+            stopwatch.Start();
+            var resultTask = await Task.WhenAny(autocompleteTask, cancelationTask);
+            stopwatch.Stop();
+
+            if (resultTask == cancelationTask)
+            {
+                if (cancel.IsCancellationRequested)
+                    trace.TraceEvent("AutocompliteCanceled", "session: {0}", session);
+                else
+                    trace.TraceEvent("AutocompliteTimeout", "session: {0}", session);
+
+                autocompleteCancel.Cancel();
+                return null;
+            }
+
+            var autocomplete = await autocompleteTask;
+            trace.TraceEvent("CallDuration", "session: {0}, duration: {1}ms", session, stopwatch.ElapsedMilliseconds);
+
+            return autocomplete;
+        }
+
+        private CodyProposalCollection CreateProposals(AutocompleteResult autocomplete, VirtualSnapshotPoint caret, CompletionState completionState, uint session)
+        {
+            var proposalList = new List<ProposalBase>();
+            if (autocomplete != null && autocomplete.Items.Any())
+            {
+                foreach (var item in autocomplete.Items)
+                {
+                    var completionText = AdjustCompletionText(caret, completionState, item.InsertText, session);
+
+                    int lenght = 0;
+                    if (item.Range.Start.Character != item.Range.End.Character || item.Range.Start.Line != item.Range.End.Line)
+                    {
+                        var startPos = ToPosition(caret.Position.Snapshot, item.Range.Start.Line, item.Range.Start.Character);
+                        var endPos = ToPosition(caret.Position.Snapshot, item.Range.End.Line, item.Range.End.Character);
+
+                        lenght = endPos - startPos;
+                    }
+
+                    var edits = new List<ProposedEdit>(1)
+                        {
+                            new ProposedEdit(new SnapshotSpan(caret.Position, lenght), completionText)
+                        };
+
+                    var proposal = Proposal.TryCreateProposal("Cody", edits, caret,
+                        completionState: completionState,
+                        proposalId: CodyProposalSourceProvider.ProposalIdPrefix + item.Id, flags: ProposalFlags.SingleTabToAccept | ProposalFlags.FormatAfterCommit);
+
+                    if (proposal != null) proposalList.Add(proposal);
+                    else trace.TraceEvent("ProposalSkipped", "session: {0}", session);
+                }
+
+            }
+
+            var collection = new CodyProposalCollection(proposalList);
+            return collection;
+        }
+
+        private string AdjustCompletionText(VirtualSnapshotPoint caret, CompletionState completionState, string completionText, uint session)
+        {
+            if (caret.IsInVirtualSpace)
+            {
+                var toSkip = Math.Min(caret.VirtualSpaces, completionText.TakeWhile(char.IsWhiteSpace).Count());
+                completionText = completionText.Substring(toSkip);
+                trace.TraceEvent("VirtualSpaceAdjustion", "session: {0}", session);
+            }
+
+            var newLineChars = view.Options.GetOptionValue(DefaultOptions.NewLineCharacterOptionId);
+            completionText = completionText.ConvertLineBreaks(newLineChars);
+
+            if (completionState == null || completionText == null) return completionText;
+            var enteredText = completionState.ApplicableToSpan.GetText();
+            var common = completionState.SelectedItem.TrimPrefix(enteredText, StringComparison.Ordinal);
+
+            if (completionText.StartsWith(common)) return completionText.Substring(common.Length);
+            else
+            {
+                trace.TraceEvent("ProposalSkipped", "session: {0}, IntellisenceMistmatch", session);
+                return string.Empty;
+            }
+        }
+
+        private Position ToLineColPosition(SnapshotPoint point)
+        {
+            var containgLine = point.GetContainingLine();
+            int col = point.Position - containgLine.Start.Position;
+            return new Position { Line = containgLine.LineNumber, Character = col };
+        }
+
+        private int ToPosition(ITextSnapshot textSnapshot, int line, int col)
+        {
+            var containgLine = textSnapshot.GetLineFromLineNumber(line);
+            return containgLine.Start.Position + col;
+        }
+
+    }
+}
diff --git a/src/Cody.VisualStudio/Completions/CodyProposalSourceProvider.cs b/src/Cody.VisualStudio/Completions/CodyProposalSourceProvider.cs
new file mode 100644
index 00000000..3c9925d3
--- /dev/null
+++ b/src/Cody.VisualStudio/Completions/CodyProposalSourceProvider.cs
@@ -0,0 +1,124 @@
+using Cody.Core.Agent.Protocol;
+using Cody.Core.Trace;
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Language.Proposals;
+using Microsoft.VisualStudio.Language.Suggestions;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+using System;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Cody.VisualStudio.Completions
+{
+    [Export(typeof(ProposalSourceProviderBase))]
+    [Name(nameof(CodyProposalSourceProvider))]
+    [Order(Before = "InlineCSharpProposalSourceProvider")]
+    //[Order(Before = "IntelliCodeCSharpProposalSource")]
+    [Order(Before = "Highest Priority")]
+    [ContentType("any")]
+    public class CodyProposalSourceProvider : ProposalSourceProviderBase, IDisposable
+    {
+        private static TraceLogger trace = new TraceLogger(nameof(CodyProposalSourceProvider));
+
+        private readonly ITextDocumentFactoryService textDocumentFactoryService;
+        private readonly IVsEditorAdaptersFactoryService editorAdaptersFactoryService;
+        private readonly SuggestionServiceBase suggestionServiceBase;
+
+        public const string ProposalIdPrefix = "cody";
+
+        //[ImportMany] public IEnumerable<ProposalSourceProviderBase> Input { get; set; }
+
+        [ImportingConstructor]
+        public CodyProposalSourceProvider(
+            ITextDocumentFactoryService textDocumentFactoryService,
+            IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
+            SuggestionServiceBase suggestionServiceBase)
+        {
+            this.textDocumentFactoryService = textDocumentFactoryService;
+            this.editorAdaptersFactoryService = editorAdaptersFactoryService;
+            this.suggestionServiceBase = suggestionServiceBase;
+
+            //suggestionServiceBase.ProposalRejected += OnProposalRejected;
+            this.suggestionServiceBase.ProposalDisplayed += OnProposalDisplayed;
+            this.suggestionServiceBase.SuggestionDismissed += OnSuggestionDismissed;
+            this.suggestionServiceBase.SuggestionAccepted += OnSuggestionAccepted;
+        }
+
+        private bool IsReadyAndIsCodyProposal(string providerName, string proposalId)
+        {
+            // e.ProviderName always return 'IntelliCodeLineCompletions' which is a VS bug
+            return CodyPackage.AgentService != null &&
+                (providerName == "IntelliCodeLineCompletions" || providerName == nameof(CodyProposalSourceProvider)) &&
+                proposalId.StartsWith(ProposalIdPrefix);
+        }
+
+        private void OnSuggestionDismissed(object sender, SuggestionDismissedEventArgs e)
+        {
+            trace.TraceEvent("SuggestionDismissed", "reason: {0}", e.Reason);
+        }
+
+        private void OnProposalDisplayed(object sender, ProposalDisplayedEventArgs e)
+        {
+            if (IsReadyAndIsCodyProposal(e.ProviderName, e.OriginalProposal.ProposalId))
+            {
+                var completionId = e.OriginalProposal.ProposalId.Substring(ProposalIdPrefix.Length);
+                var completionItem = new CompletionItemParams() { CompletionID = completionId };
+                trace.TraceEvent("ProposalDisplayed", completionId);
+                CodyPackage.AgentService.CompletionSuggested(completionItem);
+            }
+
+            if(CodyPackage.TestingSupportService != null)
+            {
+                CodyPackage.TestingSupportService.SetAutocompleteSuggestion(
+                    e.OriginalProposal.ProposalId,
+                    e.OriginalProposal.ProposalId.StartsWith(ProposalIdPrefix),
+                    e.OriginalProposal.Edits.First().ReplacementText);
+            }
+        }
+
+        private void OnSuggestionAccepted(object sender, SuggestionAcceptedEventArgs e)
+        {
+            if (IsReadyAndIsCodyProposal(e.ProviderName, e.OriginalProposal.ProposalId))
+            {
+                var completionId = e.OriginalProposal.ProposalId.Substring(ProposalIdPrefix.Length);
+                var completionItem = new CompletionItemParams() { CompletionID = completionId };
+                trace.TraceEvent("SuggestionAccepted", completionId);
+                CodyPackage.AgentService.CompletionAccepted(completionItem);
+            }
+        }
+
+        public async override Task<ProposalSourceBase> GetProposalSourceAsync(ITextView view, CancellationToken cancel)
+        {
+            //var list = Input.ToArray();
+            //foreach (var zm in Input)
+            //{
+            //    var pom = zm.GetType().Assembly.Location;
+            //}
+
+            trace.TraceEvent("Enter");
+            IWpfTextView wpfTextView = view as IWpfTextView;
+            if (wpfTextView != null && view.Roles.Contains("DOCUMENT") && view.Roles.Contains("EDITABLE"))
+            {
+                textDocumentFactoryService.TryGetTextDocument(view.TextDataModel.DocumentBuffer, out var document);
+                if (document != null)
+                {
+                    trace.TraceEvent("CreateProposalSource", "Created for '{0}'", document.FilePath);
+                    return view.Properties.GetOrCreateSingletonProperty(() => new CodyProposalSource(document, view));
+                }
+            }
+
+            return null;
+        }
+
+        public void Dispose()
+        {
+            suggestionServiceBase.ProposalDisplayed -= OnProposalDisplayed;
+            suggestionServiceBase.SuggestionDismissed -= OnSuggestionDismissed;
+            suggestionServiceBase.SuggestionAccepted -= OnSuggestionAccepted;
+        }
+    }
+}
diff --git a/src/Cody.VisualStudio/Options/GeneralOptionsPage.cs b/src/Cody.VisualStudio/Options/GeneralOptionsPage.cs
index 75a4fec3..ae839a12 100644
--- a/src/Cody.VisualStudio/Options/GeneralOptionsPage.cs
+++ b/src/Cody.VisualStudio/Options/GeneralOptionsPage.cs
@@ -1,6 +1,3 @@
-using System;
-using System.ComponentModel;
-using System.Windows;
 using Cody.Core.Logging;
 using Cody.Core.Settings;
 using Cody.UI.Controls.Options;
@@ -8,6 +5,9 @@
 using Cody.VisualStudio.Inf;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using System;
+using System.ComponentModel;
+using System.Windows;
 
 namespace Cody.VisualStudio.Options
 {
@@ -27,7 +27,7 @@ public GeneralOptionsPage()
             if (_codyPackage != null)
             {
                 _logger = _codyPackage.Logger;
-                _settingsService = _codyPackage.UserSettingsService;
+                _settingsService = CodyPackage.UserSettingsService;
 
                 _logger.Debug("Initialized.");
             }
@@ -59,9 +59,12 @@ protected override void OnActivate(CancelEventArgs e)
 
             var customConfiguration = _settingsService.CustomConfiguration;
             var acceptNonTrustedCert = _settingsService.AcceptNonTrustedCert;
+            var automaticallyTriggerCompletions = _settingsService.AutomaticallyTriggerCompletions;
 
             _generalOptionsViewModel.AcceptNonTrustedCert = acceptNonTrustedCert;
             _generalOptionsViewModel.CustomConfiguration = customConfiguration;
+            _generalOptionsViewModel.AutomaticallyTriggerCompletions = automaticallyTriggerCompletions;
+
 
             _logger.Debug($"Is canceled:{e.Cancel}");
 
@@ -73,9 +76,11 @@ protected override void OnApply(PageApplyEventArgs args)
 
             var customConfiguration = _generalOptionsViewModel.CustomConfiguration;
             var acceptNonTrustedCert = _generalOptionsViewModel.AcceptNonTrustedCert;
+            var automaticallyTriggerCompletions = _generalOptionsViewModel.AutomaticallyTriggerCompletions;
 
             _settingsService.CustomConfiguration = customConfiguration;
             _settingsService.AcceptNonTrustedCert = acceptNonTrustedCert;
+            _settingsService.AutomaticallyTriggerCompletions = automaticallyTriggerCompletions;
         }
 
         protected override void OnDeactivate(CancelEventArgs e)
@@ -96,6 +101,7 @@ public override void ResetSettings()
         {
             _settingsService.CustomConfiguration = string.Empty;
             _settingsService.AcceptNonTrustedCert = false;
+            _settingsService.AutomaticallyTriggerCompletions = true;
 
             base.ResetSettings();
         }
diff --git a/src/Cody.VisualStudio/Services/DocumentsSyncService.cs b/src/Cody.VisualStudio/Services/DocumentsSyncService.cs
index 4dbd7881..f696faa9 100644
--- a/src/Cody.VisualStudio/Services/DocumentsSyncService.cs
+++ b/src/Cody.VisualStudio/Services/DocumentsSyncService.cs
@@ -1,16 +1,16 @@
+using Cody.Core.DocumentSync;
+using Cody.Core.Logging;
+using Cody.Core.Trace;
+using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Editor;
-using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.TextManager.Interop;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Cody.Core.DocumentSync;
-using Microsoft.VisualStudio;
-using Microsoft.VisualStudio.Text.Editor;
-using Cody.Core.Logging;
-using Cody.Core.Trace;
 
 namespace Cody.VisualStudio.Services
 {
@@ -130,51 +130,55 @@ private IEnumerable<IVsWindowFrame> GetOpenDocuments()
             return results;
         }
 
-        private DocumentRange GetVisibleRange(IVsTextView textView)
+        private DocumentRange GetVisibleRange(IVsTextView textView, ITextSnapshot snapshot = null)
         {
-            const int SB_VERT = 1;
-            int visibleRows = 0, firstVisibleRow = 0;
+            DocumentPosition firstVisiblePosition = null, lastVisiblePosition = null;
+
+            if (textView != null)
+            {
+                var wpfTextView = editorAdaptersFactoryService.GetWpfTextView(textView);
+                snapshot = snapshot ?? wpfTextView.TextSnapshot;
+                var lines = wpfTextView.TextViewLines;
 
-            if (textView != null) textView.GetScrollInfo(SB_VERT, out _, out _, out visibleRows, out firstVisibleRow);
+                firstVisiblePosition = ToDocumentPosition(snapshot, lines.FirstVisibleLine.Start.Position);
+                lastVisiblePosition = ToDocumentPosition(snapshot, lines.LastVisibleLine.End.Position);
+            }
             else return null;
 
             var range = new DocumentRange
             {
-                Start = new DocumentPosition
-                {
-                    Line = Math.Max(firstVisibleRow, 0),
-                    Column = 0
-                },
-                End = new DocumentPosition
-                {
-                    Line = Math.Max(firstVisibleRow + visibleRows, 0),
-                    Column = 0
-                }
+                Start = firstVisiblePosition,
+                End = lastVisiblePosition
             };
 
             return range;
         }
 
-        private DocumentRange GetDocumentSelection(IVsTextView textView)
+        private DocumentRange GetDocumentSelection(IVsTextView textView, ITextSnapshot snapshot = null)
         {
             bool swap = false;
-            int startLine = 0, startCol = 0, endLine = 0, endCol = 0;
-            if (textView != null && ThreadHelper.CheckAccess()) textView.GetSelection(out startLine, out startCol, out endLine, out endCol);
+            DocumentPosition start = null, end = null;
+            if (textView != null)
+            {
+                var wpfTextView = editorAdaptersFactoryService.GetWpfTextView(textView);
+                if (wpfTextView != null)
+                {
+                    snapshot = snapshot ?? wpfTextView.TextSnapshot;
+                    var selection = wpfTextView.Selection;
+
+                    start = ToDocumentPosition(snapshot, selection.StreamSelectionSpan.Start.Position);
+                    end = ToDocumentPosition(snapshot, selection.StreamSelectionSpan.End.Position);
+                }
+                else return null;
+            }
+            else return null;
 
-            if (startLine > endLine || (startLine == endLine && startCol > endCol)) swap = true;
+            if(start.Line > end.Line || (start.Line == end.Line && start.Column > end.Column)) swap = true;
 
             return new DocumentRange
             {
-                Start = new DocumentPosition
-                {
-                    Line = swap ? endLine : startLine,
-                    Column = swap ? endCol : startCol,
-                },
-                End = new DocumentPosition
-                {
-                    Line = swap ? startLine : endLine,
-                    Column = swap ? startCol : endCol,
-                }
+                Start = swap ? end : start,
+                End = swap ? start : end
             };
         }
 
@@ -270,10 +274,11 @@ private void OnTextBufferChanged(object sender, TextContentChangedEventArgs e)
             try
             {
                 var path = rdt.GetDocumentInfo(activeDocument.DocCookie).Moniker;
-                var selection = GetDocumentSelection(activeDocument.TextView);
-                var changes = GetContentChanges(e.Changes, activeDocument.TextView);
-                var visibleRange = GetVisibleRange(activeDocument.TextView);
+                var selection = GetDocumentSelection(activeDocument.TextView, e.Before);
+                var changes = GetContentChanges(e.Changes, e.Before);
+                var visibleRange = GetVisibleRange(activeDocument.TextView, e.Before);
 
+                trace.TraceEvent("OnChanged", "OnTextBufferChanged");
                 documentActions.OnChanged(path, visibleRange, selection, changes);
             }
             catch (Exception ex)
@@ -292,6 +297,7 @@ private void OnSelectionChanged(object sender, EventArgs e)
                 var selection = GetDocumentSelection(activeDocument.TextView);
                 var visibleRange = GetVisibleRange(activeDocument.TextView);
 
+                trace.TraceEvent("OnChanged", "OnSelectionChanged");
                 documentActions.OnChanged(path, visibleRange, selection, Enumerable.Empty<DocumentChange>());
             }
             catch (Exception ex)
@@ -300,14 +306,14 @@ private void OnSelectionChanged(object sender, EventArgs e)
             }
         }
 
-        private IEnumerable<DocumentChange> GetContentChanges(INormalizedTextChangeCollection textChanges, IVsTextView textView)
+        private IEnumerable<DocumentChange> GetContentChanges(INormalizedTextChangeCollection textChanges, ITextSnapshot beforeSnapshot)
         {
             var results = new List<DocumentChange>();
-
+            
             foreach (var change in textChanges)
             {
-                textView.GetLineAndColumn(change.NewPosition, out int startLine, out int startCol);
-                textView.GetLineAndColumn(change.NewEnd, out int endLine, out int endCol);
+                var start = ToDocumentPosition(beforeSnapshot, change.OldPosition);
+                var end = ToDocumentPosition(beforeSnapshot,change.OldEnd);
 
                 var contentChange = new DocumentChange
                 {
@@ -316,13 +322,13 @@ private IEnumerable<DocumentChange> GetContentChanges(INormalizedTextChangeColle
                     {
                         Start = new DocumentPosition
                         {
-                            Line = startLine,
-                            Column = startCol
+                            Line = start.Line,
+                            Column = start.Column
                         },
                         End = new DocumentPosition
                         {
-                            Line = endLine,
-                            Column = endCol
+                            Line = end.Line,
+                            Column = end.Column
                         }
                     }
                 };
@@ -333,6 +339,13 @@ private IEnumerable<DocumentChange> GetContentChanges(INormalizedTextChangeColle
             return results;
         }
 
+        private DocumentPosition ToDocumentPosition(ITextSnapshot snapshot, int position)
+        {
+            var line = snapshot.GetLineFromPosition(position);
+            int col = position - line.Start.Position;
+            return new DocumentPosition { Line = line.LineNumber, Column = col };
+        }
+
         public class ActiveDocument
         {
 
diff --git a/src/Cody.VisualStudio/Services/TestingSupportService.cs b/src/Cody.VisualStudio/Services/TestingSupportService.cs
new file mode 100644
index 00000000..16106719
--- /dev/null
+++ b/src/Cody.VisualStudio/Services/TestingSupportService.cs
@@ -0,0 +1,58 @@
+using EnvDTE;
+using Microsoft.VisualStudio.TaskStatusCenter;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Cody.VisualStudio.Services
+{
+    public class TestingSupportService
+    {
+        private PropertyInfo inProgressCountProp;
+        private IVsTaskStatusCenterService statusCenterService;
+
+        private SemaphoreSlim suggestionSemaphore = new SemaphoreSlim(0, 1);
+        private AutocompleteSuggestion autocompleteSuggestion;
+
+        public TestingSupportService(IVsTaskStatusCenterService statusCenterService)
+        {
+            this.statusCenterService = statusCenterService;
+            inProgressCountProp = statusCenterService.GetType().GetProperty("InProgressCount");
+        }
+
+        public int InProgressBackgroundTasksCount => (int)inProgressCountProp.GetValue(statusCenterService);
+
+        public void SetAutocompleteSuggestion(string suggestionId, bool isCodySuggestion, string suggestionText)
+        {
+            autocompleteSuggestion = new AutocompleteSuggestion(suggestionId, isCodySuggestion, suggestionText);
+            if(suggestionSemaphore.CurrentCount == 0) suggestionSemaphore.Release();
+        }
+
+        public async Task<AutocompleteSuggestion> GetAutocompleteSuggestion(int milisecondsTimeout = 8000)
+        {
+            if(await suggestionSemaphore.WaitAsync(milisecondsTimeout))
+                return autocompleteSuggestion;
+            else
+                return null;
+        }
+
+
+        public class AutocompleteSuggestion
+        {
+            public AutocompleteSuggestion(string suggestionId, bool isCodySuggestion, string suggestionText)
+            {
+                SuggestionId = suggestionId;
+                IsCodySuggestion = isCodySuggestion;
+                SuggestionText = suggestionText;
+            }
+
+            public string SuggestionId { get; }
+            public bool IsCodySuggestion { get; }
+            public string SuggestionText { get; }
+        }
+    }
+}
diff --git a/src/Cody.VisualStudio/source.extension.vsixmanifest b/src/Cody.VisualStudio/source.extension.vsixmanifest
index eb69368a..4eb8c26b 100644
--- a/src/Cody.VisualStudio/source.extension.vsixmanifest
+++ b/src/Cody.VisualStudio/source.extension.vsixmanifest
@@ -39,5 +39,6 @@
     </Prerequisites>
     <Assets>
         <Asset Type="Microsoft.VisualStudio.VsPackage" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%;PkgdefProjectOutputGroup|" />
+        <Asset Type="Microsoft.VisualStudio.MefComponent" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%|" />
     </Assets>
 </PackageManifest>