The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
//! AI Completion for OpenIDEA: inline suggestions from an OpenAI-compatible
//! `/v1/completions` endpoint (fill-in-the-middle with `prompt` + `suffix`).
//! The IDE cancels a request as soon as the user types on (the fetch returns
//! `Cancelled`); the API key is filled in by the IDE (`{{secret:api-key}}`)
//! and never seen here.
use openidea_plugin::host::{self, storage};
use openidea_plugin::providers::{Document, InlineSuggestion, Providers};
use openidea_plugin::text::offset;
use openidea_plugin::{Error, HttpRequest, Invocation, LogLevel, NotificationLevel, Plugin, Position, register_plugin};
use serde_json::{Value, json};
const LOCAL: &str = "http://localhost:11434";
const OPENAI: &str = "https://api.openai.com";
const LOCAL_MODEL: &str = "qwen2.5-coder:1.5b";
const OPENAI_MODEL: &str = "gpt-3.5-turbo-instruct";
/// Context sent around the caret.
const PREFIX_CHARS: usize = 3000;
const SUFFIX_CHARS: usize = 1000;
#[derive(Default)]
pub struct AiCompletion {
/// Why the last request failed, so it is logged once rather than per keystroke.
last_error: Option<String>,
}
struct Config {
endpoint: String,
model: String,
openai: bool,
enabled: bool,
}
fn config() -> Config {
let get = |k: &str| storage::get(k).ok().flatten();
let endpoint = get("endpoint").unwrap_or_else(|| LOCAL.into());
let openai = endpoint.starts_with(OPENAI);
let model = get("model").unwrap_or_else(|| (if openai { OPENAI_MODEL } else { LOCAL_MODEL }).into());
Config { endpoint, model, openai, enabled: get("enabled").as_deref() != Some("false") }
}
/// The last `max` characters of `s` (on a char boundary).
fn tail(s: &str, max: usize) -> &str {
match s.char_indices().rev().nth(max.saturating_sub(1)) {
Some((i, _)) if s.chars().count() > max => &s[i..],
_ => s,
}
}
fn head(s: &str, max: usize) -> &str {
s.char_indices().nth(max).map_or(s, |(i, _)| &s[..i])
}
/// The request body for the text around `at`, or `None` when there is
/// nothing to complete (in the middle of a word).
pub fn request_body(doc: &Document, at: Position, model: &str) -> Option<String> {
let at = offset(&doc.text, at)?;
let (before, after) = doc.text.split_at(at);
// Only at the end of a line or before closing punctuation.
let rest_of_line = after.split('\n').next().unwrap_or("");
if !rest_of_line.trim().chars().all(|c| ")]}>;,'\"`".contains(c)) {
return None;
}
let body = json!({
"model": model,
"prompt": tail(before, PREFIX_CHARS),
"suffix": head(after, SUFFIX_CHARS),
"max_tokens": 64,
"temperature": 0,
"stop": ["\n\n"],
});
Some(body.to_string())
}
/// The suggestion in a `/v1/completions` response.
pub fn suggestion(response: &str) -> Option<String> {
let v: Value = serde_json::from_str(response).ok()?;
let text = v["choices"][0]["text"].as_str()?.trim_end().to_owned();
(!text.trim().is_empty()).then_some(text)
}
impl Providers for AiCompletion {
fn inline_completion(&mut self, doc: &Document, at: Position) -> Option<InlineSuggestion> {
let c = config();
if !c.enabled {
return None;
}
let body = request_body(doc, at, &c.model)?;
let mut req = HttpRequest::post(&format!("{}/v1/completions", c.endpoint.trim_end_matches('/')), body)
.header("Content-Type", "application/json");
if c.openai {
if !host::secret_is_set("api-key") {
return None;
}
req = req.header("Authorization", "Bearer {{secret:api-key}}");
}
req.timeout_ms = Some(10_000);
match host::fetch(&req) {
Ok(r) if r.status == 200 => {
self.last_error = None;
suggestion(&r.text()).map(|insert_text| InlineSuggestion { insert_text, replace: None })
}
// Superseded by the next keystroke: nothing to report.
Err(Error::Cancelled) => None,
other => {
let msg = match other {
Ok(r) => format!("HTTP {}: {}", r.status, head(&r.text(), 200)),
Err(e) => e.to_string(),
};
if self.last_error.as_ref() != Some(&msg) {
host::log(LogLevel::Warn, &format!("{}: {msg}", c.endpoint));
self.last_error = Some(msg);
}
None
}
}
}
}
impl Plugin for AiCompletion {
fn run_command(&mut self, id: &str, _ctx: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error> {
let msg = match id {
"use-local" => {
storage::set("endpoint", LOCAL)?;
storage::delete("model")?;
format!("Using the local model {LOCAL_MODEL} (Ollama at {LOCAL}).")
}
"use-openai" => {
storage::set("endpoint", OPENAI)?;
storage::delete("model")?;
if host::secret_is_set("api-key") {
format!("Using OpenAI ({OPENAI_MODEL}).")
} else {
"Using OpenAI: store your API key in Settings › Plugins › AI Completion.".into()
}
}
"set-endpoint" => {
let url = arg.map(str::trim).filter(|u| u.starts_with("http://") || u.starts_with("https://"));
let url = url.ok_or("give the endpoint URL, e.g. http://localhost:11434")?;
storage::set("endpoint", url)?;
format!("Using {url}.")
}
"toggle" => {
let enabled = !config().enabled;
storage::set("enabled", if enabled { "true" } else { "false" })?;
(if enabled { "AI Completion is on." } else { "AI Completion is off." }).into()
}
_ => return Err(Error::NotFound(format!("command {id}"))),
};
host::notify(NotificationLevel::Info, "AI Completion", &msg);
Ok(Some(msg))
}
}
register_plugin!(AiCompletion, providers);
#[cfg(test)]
mod tests {
use super::*;
use openidea_plugin::HttpResponse;
use openidea_plugin::mock::MockHost;
fn doc(text: &str) -> Document {
Document { path: "/p/a.rs".into(), language: "rust".into(), version: 1, text: text.into() }
}
#[test]
fn asks_with_prefix_and_suffix_and_returns_the_text() {
let host = MockHost::install().with_capabilities(&["storage", "net:localhost"]);
host.on_fetch(|r| {
let body: Value = serde_json::from_slice(r.body.as_ref().unwrap()).unwrap();
assert_eq!(body["prompt"], "fn add(a: i32, b: i32) -> i32 {\n ");
assert_eq!(body["suffix"], "\n}\n");
Ok(HttpResponse { status: 200, headers: vec![], body: br#"{"choices":[{"text":"a + b\n"}]}"#.to_vec() })
});
let s = AiCompletion::default()
.inline_completion(&doc("fn add(a: i32, b: i32) -> i32 {\n \n}\n"), Position::new(1, 4))
.unwrap();
assert_eq!(s.insert_text, "a + b");
assert_eq!(host.requests()[0].url, "http://localhost:11434/v1/completions");
}
#[test]
fn openai_uses_the_secret_and_only_when_set() {
let host = MockHost::install().with_capabilities(&["storage", "net:api.openai.com", "secrets"]);
host.on_fetch(|_| {
Ok(HttpResponse { status: 200, headers: vec![], body: br#"{"choices":[{"text":"x"}]}"#.to_vec() })
});
let mut p = AiCompletion::default();
p.run_command("use-openai", &host.invocation(), None).unwrap();
assert!(p.inline_completion(&doc("let x = "), Position::new(0, 8)).is_none(), "no key yet");
host.set_secret("api-key", "sk-test");
assert!(p.inline_completion(&doc("let x = "), Position::new(0, 8)).is_some());
let sent = &host.requests()[0];
assert!(sent.headers.contains(&("Authorization".into(), "Bearer sk-test".into())));
}
#[test]
fn quiet_when_cancelled_denied_or_mid_word() {
let host = MockHost::install().with_capabilities(&["storage"]);
let mut p = AiCompletion::default();
assert!(p.inline_completion(&doc("let x = "), Position::new(0, 8)).is_none(), "net denied");
assert!(request_body(&doc("let abc = d;"), Position::new(0, 5), "m").is_none(), "mid-word");
assert!(request_body(&doc("call(x)"), Position::new(0, 6), "m").is_some(), "before `)`");
let host2 = MockHost::install().with_capabilities(&["storage", "net:localhost"]);
host2.on_fetch(|_| Err(Error::Cancelled));
assert!(p.inline_completion(&doc("x"), Position::new(0, 1)).is_none());
assert!(host2.logs().is_empty(), "a cancelled request is not an error");
drop(host);
p.run_command("toggle", &host2.invocation(), None).unwrap();
assert!(p.inline_completion(&doc("x"), Position::new(0, 1)).is_none());
assert_eq!(host2.requests().len(), 1, "disabled: no request");
}
}