feat(context)!: implement schema-based contexts

Redesign the context system to use JSON schema for validating and
parsing inputs instead of callback-based approach. This improves the
user experience by:

- Adding structured input validation with schemas
- Enhancing context documentation with auto-generated descriptions
- Moving context help text from client to prompt template
- Supporting multiple input parameters with separator-based parsing
- Simplifying context resolution with declarative definitions

BREAKING CHANGE: The context API has changed from callback-based input handling to schema-based definitions.

Signed-off-by: Tomas Slusny <slusnucky@gmail.com>

Author: deathbeam

README.md

@@ -339,6 +339,7 @@ Examples:
 > #git:staged
 > #url:https://example.com
 > #system:`ls -la | grep lua`
+> #command:`with;;multiple;;parameters`
 ```
 
 Define your own contexts in the configuration with input handling and resolution:
@@ -347,17 +348,22 @@ Define your own contexts in the configuration with input handling and resolution
 {
   contexts = {
     birthday = {
-      input = function(callback)
-        vim.ui.select({ 'user', 'napoleon' }, {
-          prompt = 'Select birthday> ',
-        }, callback)
-      end,
+      schema = {
+        type = 'object',
+        required = { 'name' },
+        properties = {
+          name = {
+            type = 'string'
+            enum = { 'Alice', 'Bob', 'Charlie' },
+          },
+        },
+      },
+
       resolve = function(input)
         return {
           {
-            content = input .. ' birthday info',
-            filename = input .. '_birthday',
-            filetype = 'text',
+            type = 'text',
+            text = input.name .. ' birthday info',
           }
         }
       end

lua/CopilotChat/client.lua

@@ -1,6 +1,5 @@
 ---@class CopilotChat.Client.ask
 ---@field headless boolean
----@field contexts table<string, string>?
 ---@field selection CopilotChat.select.selection?
 ---@field embeddings table<CopilotChat.context.embed>?
 ---@field system_prompt string
@@ -195,49 +194,14 @@ end
 
 --- Generate ask request
 --- @param history table<CopilotChat.Provider.input>
---- @param contexts table<string, string>?
 --- @param prompt string
 --- @param system_prompt string
 --- @param generated_messages table<CopilotChat.Provider.input>
-local function generate_ask_request(history, contexts, prompt, system_prompt, generated_messages)
+local function generate_ask_request(history, prompt, system_prompt, generated_messages)
   local messages = {}
 
   system_prompt = vim.trim(system_prompt)
 
-  -- Include context help
-  if contexts and not vim.tbl_isempty(contexts) then
-    local help_text = [[When you need additional context, request it using this format:
-
-> #<command>:`<input>`
-
-Examples:
-> #file:`path/to/file.js`        (loads specific file)
-> #buffers:`visible`             (loads all visible buffers)
-> #git:`staged`                  (loads git staged changes)
-> #system:`uname -a`             (loads system information)
-
-Guidelines:
-- Always request context when needed rather than guessing about files or code
-- Use the > format on a new line when requesting context
-- Output context commands directly - never ask if the user wants to provide information
-- Assume the user will provide requested context in their next response
-
-Available context providers and their usage:]]
-
-    local context_names = vim.tbl_keys(contexts)
-    table.sort(context_names)
-    for _, name in ipairs(context_names) do
-      local description = contexts[name]
-      description = description:gsub('\n', '\n   ')
-      help_text = help_text .. '\n\n - #' .. name .. ': ' .. description
-    end
-
-    if system_prompt ~= '' then
-      system_prompt = system_prompt .. '\n\n'
-    end
-    system_prompt = system_prompt .. help_text
-  end
-
   -- Include system prompt
   if not utils.empty(system_prompt) then
     table.insert(messages, {
@@ -656,10 +620,8 @@ function Client:ask(prompt, opts)
   end
 
   local headers = self:authenticate(provider_name)
-  local request = provider.prepare_input(
-    generate_ask_request(history, opts.contexts, prompt, opts.system_prompt, generated_messages),
-    options
-  )
+  local request =
+    provider.prepare_input(generate_ask_request(history, prompt, opts.system_prompt, generated_messages), options)
   local is_stream = request.stream
 
   local args = {

lua/CopilotChat/config/contexts.lua

@@ -3,98 +3,114 @@ local utils = require('CopilotChat.utils')
 
 ---@class CopilotChat.config.context
 ---@field description string?
----@field input fun(callback: fun(input: string?), source: CopilotChat.source)?
----@field resolve fun(input: string?, source: CopilotChat.source, prompt: string):table<CopilotChat.context.embed>
+---@field schema table?
+---@field resolve fun(input: table, source: CopilotChat.source, prompt: string):table<CopilotChat.context.embed>
 
 ---@type table<string, CopilotChat.config.context>
 return {
   buffer = {
-    description = 'Includes specified buffer in chat context. Supports input (default current).',
-    input = function(callback)
-      vim.ui.select(
-        vim.tbl_map(
-          function(buf)
-            return { id = buf, name = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(buf), ':p:.') }
-          end,
-          vim.tbl_filter(function(buf)
-            return utils.buf_valid(buf) and vim.fn.buflisted(buf) == 1
-          end, vim.api.nvim_list_bufs())
-        ),
-        {
-          prompt = 'Select a buffer> ',
-          format_item = function(item)
-            return item.name
+    description = 'Includes specified buffer in chat context.',
+
+    schema = {
+      type = 'object',
+      properties = {
+        bufnr = {
+          type = 'integer',
+          description = 'Buffer number to include in chat context.',
+          enum = function()
+            return vim.tbl_map(
+              function(buf)
+                return buf
+              end,
+              vim.tbl_filter(function(buf)
+                return utils.buf_valid(buf) and vim.fn.buflisted(buf) == 1
+              end, vim.api.nvim_list_bufs())
+            )
           end,
         },
-        function(choice)
-          callback(choice and choice.id)
-        end
-      )
-    end,
-    resolve = function(input, source)
-      input = input and tonumber(input) or source.bufnr
+      },
+    },
 
+    resolve = function(input, source)
       utils.schedule_main()
       return {
-        context.get_buffer(input),
+        context.get_buffer(input.bufnr or source.bufnr),
       }
     end,
   },
 
   buffers = {
-    description = 'Includes all buffers in chat context. Supports input (default listed).',
-    input = function(callback)
-      vim.ui.select({ 'listed', 'visible' }, {
-        prompt = 'Select buffer scope> ',
-      }, callback)
-    end,
-    resolve = function(input)
-      input = input or 'listed'
+    description = 'Includes all buffers in chat context.',
+
+    schema = {
+      type = 'object',
+      properties = {
+        scope = {
+          type = 'string',
+          description = 'Scope of buffers to include in chat context.',
+          enum = { 'listed', 'visible' },
+          default = 'listed',
+        },
+      },
+    },
 
+    resolve = function(input)
       utils.schedule_main()
       return vim.tbl_map(
         context.get_buffer,
         vim.tbl_filter(function(b)
-          return utils.buf_valid(b) and vim.fn.buflisted(b) == 1 and (input == 'listed' or #vim.fn.win_findbuf(b) > 0)
+          return utils.buf_valid(b)
+            and vim.fn.buflisted(b) == 1
+            and (input.scope == 'listed' or #vim.fn.win_findbuf(b) > 0)
         end, vim.api.nvim_list_bufs())
       )
     end,
   },
 
   file = {
-    description = 'Includes content of provided file in chat context. Supports input.',
-    input = function(callback, source)
-      local files = utils.scan_dir(source.cwd(), {
-        max_count = 0,
-      })
+    description = 'Includes content of provided file in chat context.',
+
+    schema = {
+      type = 'object',
+      required = { 'file' },
+      properties = {
+        file = {
+          type = 'string',
+          description = 'File to include in chat context.',
+          enum = function(source)
+            return utils.scan_dir(source.cwd(), {
+              max_count = 0,
+            })
+          end,
+        },
+      },
+    },
 
-      utils.schedule_main()
-      vim.ui.select(files, {
-        prompt = 'Select a file> ',
-      }, callback)
-    end,
     resolve = function(input)
-      if not input or input == '' then
-        return {}
-      end
-
       utils.schedule_main()
       return {
-        context.get_file(utils.filepath(input), utils.filetype(input)),
+        context.get_file(utils.filepath(input.file), utils.filetype(input.file)),
       }
     end,
   },
 
   files = {
-    description = 'Includes all non-hidden files in the current workspace in chat context. Supports input (glob pattern).',
-    input = function(callback)
-      vim.ui.input({
-        prompt = 'Enter glob> ',
-      }, callback)
-    end,
+    description = 'Includes all non-hidden files in the current workspace in chat context.',
+
+    schema = {
+      type = 'object',
+      properties = {
+        glob = {
+          type = 'string',
+          description = 'Glob pattern to match files.',
+          default = '**/*',
+        },
+      },
+    },
+
     resolve = function(input, source)
       local files = utils.scan_dir(source.cwd(), {
-        glob = input,
+        glob = input.glob,
       })
 
       utils.schedule_main()
@@ -123,16 +139,23 @@ return {
   },
 
   filenames = {
-    description = 'Includes names of all non-hidden files in the current workspace in chat context. Supports input (glob pattern).',
-    input = function(callback)
-      vim.ui.input({
-        prompt = 'Enter glob> ',
-      }, callback)
-    end,
+    description = 'Includes names of all non-hidden files in the current workspace in chat context.',
+
+    schema = {
+      type = 'object',
+      properties = {
+        glob = {
+          type = 'string',
+          description = 'Glob pattern to match files.',
+          default = '**/*',
+        },
+      },
+    },
+
     resolve = function(input, source)
       local out = {}
       local files = utils.scan_dir(source.cwd(), {
-        glob = input,
+        glob = input.glob,
       })
 
       local chunk_size = 100
@@ -158,14 +181,21 @@ return {
   },
 
   git = {
-    description = 'Requires `git`. Includes current git diff in chat context. Supports input (default unstaged, also accepts commit number).',
-    input = function(callback)
-      vim.ui.select({ 'unstaged', 'staged' }, {
-        prompt = 'Select diff type> ',
-      }, callback)
-    end,
+    description = 'Requires `git`. Includes current git diff in chat context.',
+
+    schema = {
+      type = 'object',
+      properties = {
+        diff = {
+          type = 'string',
+          description = 'Git diff to include in chat context.',
+          enum = { 'unstaged', 'staged', 'git sha' },
+          default = 'unstaged',
+        },
+      },
+    },
+
     resolve = function(input, source)
-      input = input or 'unstaged'
       local cmd = {
         'git',
         '-C',
@@ -175,80 +205,85 @@ return {
         '--no-ext-diff',
       }
 
-      if input == 'staged' then
+      if input.diff == 'staged' then
         table.insert(cmd, '--staged')
-      elseif input == 'unstaged' then
+      elseif input.diff == 'unstaged' then
         table.insert(cmd, '--')
       else
-        table.insert(cmd, input)
+        table.insert(cmd, input.diff)
       end
 
       local out = utils.system(cmd)
 
       return {
         {
           content = out.stdout,
-          filename = 'git_diff_' .. input,
+          filename = 'git_diff_' .. input.diff,
           filetype = 'diff',
         },
       }
     end,
   },
 
   url = {
-    description = 'Includes content of provided URL in chat context. Supports input.',
-    input = function(callback)
-      vim.ui.input({
-        prompt = 'Enter URL> ',
-        default = 'https://',
-      }, callback)
-    end,
+    description = 'Includes content of provided URL in chat context.',
+
+    schema = {
+      type = 'object',
+      required = { 'url' },
+      properties = {
+        url = {
+          type = 'string',
+          description = 'URL to include in chat context.',
+        },
+      },
+    },
+
     resolve = function(input)
       return {
-        context.get_url(input),
+        context.get_url(input.url),
       }
     end,
   },
 
   register = {
-    description = 'Includes contents of register in chat context. Supports input (default +, e.g clipboard).',
-    input = function(callback)
-      local choices = utils.kv_list({
-        ['+'] = 'synchronized with the system clipboard',
-        ['*'] = 'synchronized with the selection clipboard',
-        ['"'] = 'last deleted, changed, or yanked content',
-        ['0'] = 'last yank',
-        ['-'] = 'deleted or changed content smaller than one line',
-        ['.'] = 'last inserted text',
-        ['%'] = 'name of the current file',
-        [':'] = 'most recent executed command',
-        ['#'] = 'alternate buffer',
-        ['='] = 'result of an expression',
-        ['/'] = 'last search pattern',
-      })
+    description = 'Includes contents of register in chat context.',
+
+    schema = {
+      type = 'object',
+      properties = {
+        register = {
+          type = 'string',
+          description = 'Register to include in chat context.',
+          enum = {
+            '+',
+            '*',
+            '"',
+            '0',
+            '-',
+            '.',
+            '%',
+            ':',
+            '#',
+            '=',
+            '/',
+          },
+          default = '+',
+        },
+      },
+    },
 
-      vim.ui.select(choices, {
-        prompt = 'Select a register> ',
-        format_item = function(choice)
-          return choice.key .. ' - ' .. choice.value
-        end,
-      }, function(choice)
-        callback(choice and choice.key)
-      end)
-    end,
     resolve = function(input)
-      input = input or '+'
-
       utils.schedule_main()
-      local lines = vim.fn.getreg(input)
+      local lines = vim.fn.getreg(input.register)
       if not lines or lines == '' then
         return {}
       end
 
       return {
         {
           content = lines,
-          filename = 'vim_register_' .. input,
+          filename = 'vim_register_' .. input.register,
           filetype = '',
         },
       }
@@ -257,6 +292,7 @@ return {
 
   quickfix = {
     description = 'Includes quickfix list file contents in chat context.',
+
     resolve = function()
       utils.schedule_main()
 
@@ -298,23 +334,26 @@ return {
   },
 
   system = {
-    description = [[Includes output of provided system shell command in chat context. Supports input.
+    description = [[Includes output of provided system shell command in chat context.
 
 Important:
 - Only use system commands as last resort, they are run every time the context is requested.
 - For example instead of curl use the url context, instead of finding and grepping try to check if there is any context that can query the data you need instead.
 - If you absolutely need to run a system command, try to use read-only commands and avoid commands that modify the system state.
 ]],
-    input = function(callback)
-      vim.ui.input({
-        prompt = 'Enter command> ',
-      }, callback)
-    end,
-    resolve = function(input)
-      if not input or input == '' then
-        return {}
-      end
 
+    schema = {
+      type = 'object',
+      required = { 'command' },
+      properties = {
+        command = {
+          type = 'string',
+          description = 'System command to include in chat context.',
+        },
+      },
+    },
+
+    resolve = function(input)
       utils.schedule_main()
 
       local shell, shell_flag
@@ -324,7 +363,7 @@ Important:
         shell, shell_flag = 'sh', '-c'
       end
 
-      local out = utils.system({ shell, shell_flag, input })
+      local out = utils.system({ shell, shell_flag, input.command })
       if not out then
         return {}
       end
@@ -343,7 +382,7 @@ Important:
       return {
         {
           content = out_text,
-          filename = out_type .. '_' .. input:gsub('[^%w]', '_'):sub(1, 20),
+          filename = out_type .. '_' .. input.command:gsub('[^%w]', '_'):sub(1, 20),
           filetype = 'text',
         },
       }

lua/CopilotChat/config/prompts.lua

@@ -1,13 +1,12 @@
-local COPILOT_BASE = string.format(
-  [[
+local COPILOT_BASE = [[
 When asked for your name, you must respond with "GitHub Copilot".
 Follow the user's requirements carefully & to the letter.
 Follow Microsoft content policies.
 Avoid content that violates copyrights.
 If you are asked to generate content that is harmful, hateful, racist, sexist, lewd, violent, or completely irrelevant to software engineering, only respond with "Sorry, I can't assist with that."
 Keep your answers short and impersonal.
 The user works in an IDE called Neovim which has a concept for editors with open files, integrated unit test support, an output pane that shows the output of running the code as well as an integrated terminal.
-The user is working on a %s machine. Please respond with system specific commands if applicable.
+The user is working on a {OS_NAME} machine. Please respond with system specific commands if applicable.
 You will receive code snippets that include line number prefixes - use these to maintain correct position references but remove them when generating output.
 
 When presenting code changes:
@@ -27,9 +26,34 @@ When presenting code changes:
 5. Address any diagnostics issues when fixing code.
 
 6. If multiple changes are needed, present them as separate blocks with their own headers.
-]],
-  vim.uv.os_uname().sysname
-)
+
+When you need additional context, request it using this format instead of guessing or making assumptions:
+
+> #<command>:`<input>`                      (single input parameter)
+> #<command>:`<param1>;;<param2>;;<param3>` (multiple input parameters)
+
+Examples:
+
+> #file:`path/to/file.js`        (loads specific file)
+> #buffers:`visible`             (loads all visible buffers)
+> #git:`staged`                  (loads git staged changes)
+> #system:`uname -a`             (loads system information)
+
+Guidelines:
+- Always request context when possible instead of guessing and making assumptions
+- Use the > format on a new line when requesting context
+- Output context commands directly - never ask if the user wants to provide information
+- Assume the user will provide requested context in their next response
+- When showing only examples of context usage (not for execution), wrap them in triple backticks to prevent execution:
+
+```
+> #file:`your-file.js`
+```
+
+Available context providers and their usage:
+
+{CONTEXTS}
+]]
 
 local COPILOT_INSTRUCTIONS = [[
 You are a code-focused AI programming assistant that specializes in practical software engineering solutions.

lua/CopilotChat/context.lua

@@ -69,6 +69,8 @@ local OFF_SIDE_RULE_LANGUAGES = {
   'fsharp',
 }
 
+local INPUT_SEPARATOR = ';;'
+
 local MULTI_FILE_THRESHOLD = 5
 
 --- Compute the cosine similarity between two vectors
@@ -397,6 +399,248 @@ local function get_outline(content, ft)
   return table.concat(outline_lines, '\n'), symbols
 end
 
+local function sorted_propnames(schema)
+  local prop_names = vim.tbl_keys(schema.properties)
+  local required_set = {}
+  if schema.required then
+    for _, name in ipairs(schema.required) do
+      required_set[name] = true
+    end
+  end
+
+  -- Sort properties with priority: required without default > required with default > optional
+  table.sort(prop_names, function(a, b)
+    local a_required = required_set[a] or false
+    local b_required = required_set[b] or false
+    local a_has_default = schema.properties[a].default ~= nil
+    local b_has_default = schema.properties[b].default ~= nil
+
+    -- First priority: required properties without default
+    if a_required and not a_has_default and (not b_required or b_has_default) then
+      return true
+    end
+    if b_required and not b_has_default and (not a_required or a_has_default) then
+      return false
+    end
+
+    -- Second priority: required properties with default
+    if a_required and not b_required then
+      return true
+    end
+    if b_required and not a_required then
+      return false
+    end
+
+    -- Finally sort alphabetically
+    return a < b
+  end)
+
+  return prop_names
+end
+
+--- Serialize a JSON schema to human-readable text format
+---@param schema table
+---@param indent string?
+---@return string
+local function describe_schema(schema, indent)
+  indent = indent or ''
+  local result = {}
+
+  -- Handle basic schema types
+  if schema.type then
+    table.insert(result, indent .. 'Type: ' .. schema.type)
+  end
+
+  -- Add description if available
+  if schema.description then
+    table.insert(result, indent .. 'Description: ' .. schema.description)
+  end
+
+  -- Add required field information
+  if schema.required and #schema.required > 0 then
+    table.insert(result, indent .. 'Required: ' .. table.concat(schema.required, ', '))
+  end
+
+  -- Handle properties for object types
+  if schema.properties then
+    table.insert(result, indent .. 'Properties:')
+    local prop_names = sorted_propnames(schema)
+    for _, name in ipairs(prop_names) do
+      local prop = schema.properties[name]
+      table.insert(result, indent .. '  ' .. name .. ':')
+      local nested_text = describe_schema(prop, indent .. '    ')
+      table.insert(result, nested_text)
+    end
+  end
+
+  -- Handle arrays
+  if schema.items then
+    table.insert(result, indent .. 'Items:')
+    local items_text = describe_schema(schema.items, indent .. '  ')
+    table.insert(result, items_text)
+  end
+
+  -- Handle enums
+  if schema.enum and type(schema.enum) == 'table' then
+    table.insert(result, indent .. 'Allowed values: ' .. table.concat(schema.enum, ', '))
+  end
+
+  -- Add default value information
+  if schema.default ~= nil then
+    table.insert(result, indent .. 'Default: ' .. schema.default)
+  end
+
+  return table.concat(result, '\n')
+end
+
+--- Get input format information for a context
+---@param context_name string
+---@param context_config CopilotChat.config.context
+---@return string
+function M.describe_context(context_name, context_config)
+  local function resolve_prop_value(prop_name)
+    local prop_schema = context_config.schema.properties[prop_name]
+    local example_value = ''
+    if prop_schema.default ~= nil then
+      example_value = prop_schema.default
+    elseif prop_schema.enum and type(prop_schema.enum) == 'table' then
+      example_value = prop_schema.enum[1]
+    elseif prop_schema.type == 'string' then
+      example_value = 'example-' .. prop_name
+    elseif prop_schema.type == 'integer' then
+      example_value = '42'
+    elseif prop_schema.type == 'boolean' then
+      example_value = 'true'
+    else
+      example_value = '<' .. prop_name .. '>'
+    end
+    return example_value
+  end
+
+  local result = {}
+
+  table.insert(result, '## ' .. context_name)
+
+  if context_config.description then
+    table.insert(result, vim.trim(context_config.description))
+  end
+
+  table.insert(result, '')
+
+  if context_config.schema then
+    table.insert(result, '### Input format')
+    table.insert(result, describe_schema(context_config.schema))
+    table.insert(result, '')
+  end
+
+  table.insert(result, '### Example usage:')
+  table.insert(result, '```')
+  if context_config.schema then
+    local prop_names = sorted_propnames(context_config.schema)
+
+    local values = {}
+    for _, prop_name in ipairs(prop_names) do
+      table.insert(values, '<' .. prop_name .. '>')
+    end
+    table.insert(result, string.format('#%s:`%s`', context_name, table.concat(values, INPUT_SEPARATOR)))
+
+    if utils.empty(context_config.schema.required) then
+      table.insert(result, '#' .. context_name)
+    else
+      values = {}
+      for _, prop_name in ipairs(prop_names) do
+        if vim.tbl_contains(context_config.schema.required, prop_name) then
+          table.insert(values, resolve_prop_value(prop_name))
+        end
+      end
+      table.insert(result, string.format('#%s:`%s`', context_name, table.concat(values, INPUT_SEPARATOR)))
+    end
+
+    values = {}
+    for _, prop_name in ipairs(prop_names) do
+      table.insert(values, resolve_prop_value(prop_name))
+    end
+    table.insert(result, string.format('#%s:`%s`', context_name, table.concat(values, INPUT_SEPARATOR)))
+  else
+    table.insert(result, '#' .. context_name)
+  end
+
+  table.insert(result, '```')
+  table.insert(result, '')
+  return table.concat(result, '\n')
+end
+
+--- Parse context input string into a table based on the schema
+---@param input string?
+---@param schema table?
+---@return table
+function M.parse_input(input, schema)
+  if not input or input == '' or not schema or not schema.properties then
+    return {}
+  end
+
+  local parts = vim.split(input, INPUT_SEPARATOR)
+  local result = {}
+  local prop_names = sorted_propnames(schema)
+
+  -- Map input parts to schema properties in sorted order
+  local i = 1
+  for _, prop_name in ipairs(prop_names) do
+    local prop_schema = schema.properties[prop_name]
+    local value = parts[i] ~= '' and parts[i] or nil
+    if value == nil and prop_schema.default ~= nil then
+      value = prop_schema.default
+    end
+
+    result[prop_name] = value
+    i = i + 1
+    if i > #parts then
+      break
+    end
+  end
+
+  return result
+end
+
+--- Get input from the user based on the schema
+---@param schema table?
+---@param source CopilotChat.source
+---@return string?
+function M.enter_input(schema, source)
+  if not schema or not schema.properties then
+    return nil
+  end
+
+  local prop_names = sorted_propnames(schema)
+  local out = {}
+
+  for _, prop_name in ipairs(prop_names) do
+    local cfg = schema.properties[prop_name]
+    if cfg.enum then
+      local choices = type(cfg.enum) == 'table' and cfg.enum or cfg.enum(source)
+      local choice = utils.select(choices, {
+        prompt = string.format('Select %s> ', prop_name),
+      })
+
+      table.insert(out, choice or '')
+    elseif cfg.type == 'boolean' then
+      table.insert(out, utils.select({ 'true', 'false' }, {
+        prompt = string.format('Select %s> ', prop_name),
+      }) or '')
+    else
+      table.insert(out, utils.input({
+        prompt = string.format('Enter %s> ', prop_name),
+      }) or '')
+    end
+  end
+
+  local out = vim.trim(table.concat(out, INPUT_SEPARATOR))
+  if out:match('%s+') then
+    out = string.format('`%s`', out)
+  end
+  return out
+end
+
 --- Get data for a file
 ---@param filename string
 ---@param filetype string?

lua/CopilotChat/init.lua

@@ -6,8 +6,9 @@ local notify = require('CopilotChat.notify')
 local utils = require('CopilotChat.utils')
 
 local PLUGIN_NAME = 'CopilotChat'
-local WORD = '([^%s]+)'
-local WORD_INPUT = '([^%s:]+:`[^`]+`)'
+local WORD = '([^%s:]+)'
+local WORD_WITH_INPUT_UNQUOTED = WORD .. ':([^%s]+)'
+local WORD_WITH_INPUT_QUOTED = WORD .. ':`([^`]+)`'
 
 ---@class CopilotChat
 ---@field config CopilotChat.config
@@ -303,6 +304,24 @@ function M.resolve_prompt(prompt, config)
   if prompts_to_use[config.system_prompt] then
     config.system_prompt = prompts_to_use[config.system_prompt].system_prompt
   end
+
+  if config.system_prompt then
+    config.system_prompt = config.system_prompt:gsub('{OS_NAME}', vim.uv.os_uname().sysname)
+
+    local context_string = ''
+    local context_names = vim.tbl_keys(M.config.contexts)
+    table.sort(context_names)
+    for _, name in ipairs(context_names) do
+      local ctx = M.config.contexts[name]
+      context_string = context_string .. context.describe_context(name, ctx) .. '\n'
+    end
+    context_string = vim.trim(context_string)
+
+    if context_string ~= '' then
+      config.system_prompt = config.system_prompt:gsub('{CONTEXTS}', context_string)
+    end
+  end
+
   return config, prompt
 end
 
@@ -315,18 +334,12 @@ function M.resolve_context(prompt, config)
   config, prompt = M.resolve_prompt(prompt, config)
 
   local contexts = {}
-  local function parse_context(prompt_context)
-    local split = vim.split(prompt_context, ':')
-    local context_name = table.remove(split, 1)
-    local context_input = vim.trim(table.concat(split, ':'))
-    if vim.startswith(context_input, '`') and vim.endswith(context_input, '`') then
-      context_input = context_input:sub(2, -2)
-    end
-
-    if M.config.contexts[context_name] then
+  local function parse_context(word, input)
+    local ctx = M.config.contexts[word]
+    if ctx then
       table.insert(contexts, {
-        name = context_name,
-        input = (context_input ~= '' and context_input or nil),
+        name = word,
+        input = context.parse_input(input, ctx.schema),
       })
 
       return true
@@ -335,12 +348,16 @@ function M.resolve_context(prompt, config)
     return false
   end
 
-  prompt = prompt:gsub('#' .. WORD_INPUT, function(match)
-    return parse_context(match) and '' or '#' .. match
+  prompt = prompt:gsub('#' .. WORD_WITH_INPUT_QUOTED, function(word, input)
+    return parse_context(word, input) and '' or string.format('#%s:`%s`', word, input)
+  end)
+
+  prompt = prompt:gsub('#' .. WORD_WITH_INPUT_UNQUOTED, function(word, input)
+    return parse_context(word, input) and '' or string.format('#%s:%s', word, input)
   end)
 
-  prompt = prompt:gsub('#' .. WORD, function(match)
-    return parse_context(match) and '' or '#' .. match
+  prompt = prompt:gsub('#' .. WORD, function(word)
+    return parse_context(word) and '' or string.format('#%s', word)
   end)
 
   if config.context then
@@ -357,11 +374,7 @@ function M.resolve_context(prompt, config)
   local embeddings = utils.ordered_map()
   for _, context_data in ipairs(contexts) do
     local context_value = M.config.contexts[context_data.name]
-    notify.publish(
-      notify.STATUS,
-      'Resolving context: ' .. context_data.name .. (context_data.input and ' with input: ' .. context_data.input or '')
-    )
-
+    notify.publish(notify.STATUS, 'Resolving context: ' .. context_data.name)
     local ok, resolved_embeddings = pcall(context_value.resolve, context_data.input, state.source or {}, prompt)
     if ok then
       for _, embedding in ipairs(resolved_embeddings) do
@@ -525,21 +538,16 @@ function M.trigger_complete(without_context)
 
   if not without_context and vim.startswith(prefix, '#') and vim.endswith(prefix, ':') then
     local found_context = M.config.contexts[prefix:sub(2, -2)]
-    if found_context and found_context.input then
+    if found_context and found_context.schema then
       async.run(function()
-        found_context.input(function(value)
-          if not value then
-            return
-          end
-
-          local value_str = vim.trim(tostring(value))
-          if value_str:find('%s') then
-            value_str = '`' .. value_str .. '`'
-          end
+        local value = context.enter_input(found_context.schema, state.source)
+        if not value then
+          return
+        end
 
-          vim.api.nvim_buf_set_text(bufnr, row - 1, col, row - 1, col, { value_str })
-          vim.api.nvim_win_set_cursor(0, { row, col + #value_str })
-        end, state.source or {})
+        utils.schedule_main()
+        vim.api.nvim_buf_set_text(bufnr, row - 1, col, row - 1, col, { value })
+        vim.api.nvim_win_set_cursor(0, { row, col + #value })
       end)
     end
 
@@ -634,8 +642,8 @@ function M.complete_items()
       word = '#' .. name,
       abbr = name,
       kind = 'context',
-      info = value.description or '',
-      menu = value.input and string.format('#%s:<input>', name) or string.format('#%s', name),
+      info = context.describe_context(name, value),
+      menu = vim.split(vim.trim(value.description or ''), '\n')[1],
       icase = 1,
       dup = 0,
       empty = 0,
@@ -848,14 +856,6 @@ function M.ask(prompt, config)
   config, prompt = M.resolve_prompt(prompt, config)
   local system_prompt = config.system_prompt or ''
 
-  -- Resolve context name and description
-  local contexts = {}
-  for name, context in pairs(M.config.contexts) do
-    if context.description then
-      contexts[name] = context.description
-    end
-  end
-
   -- Remove sticky prefix
   prompt = table.concat(
     vim.tbl_map(function(l)
@@ -886,7 +886,6 @@ function M.ask(prompt, config)
 
     local ask_ok, response, references, token_count, token_max_count = pcall(client.ask, client, prompt, {
       headless = config.headless,
-      contexts = contexts,
       selection = selection,
       embeddings = filtered_embeddings,
       system_prompt = system_prompt,

lua/CopilotChat/utils.lua

@@ -699,6 +699,46 @@ M.ts_parse = async.wrap(function(parser, callback)
   end
 end, 2)
 
+--- Wait for a user input
+M.input = async.wrap(function(opts, callback)
+  local fn = function()
+    vim.ui.input(opts, function(input)
+      if input == nil or input == '' then
+        callback(nil)
+        return
+      end
+
+      callback(input)
+    end)
+  end
+
+  if vim.in_fast_event() then
+    vim.schedule(fn)
+  else
+    fn()
+  end
+end, 2)
+
+--- Select an item from a list
+M.select = async.wrap(function(choices, opts, callback)
+  local fn = function()
+    vim.ui.select(choices, opts, function(item)
+      if item == nil or item == '' then
+        callback(nil)
+        return
+      end
+
+      callback(item)
+    end)
+  end
+
+  if vim.in_fast_event() then
+    vim.schedule(fn)
+  else
+    fn()
+  end
+end, 3)
+
 --- Get the info for a key.
 ---@param name string
 ---@param key table