1use crate::{
2 http::{Request, Transport, read_json},
3 identity::{ProcessIdentity, ProcessProbe},
4 process_control::{
5 ProcessControl, SpawnSpec, listener, minimal_env, same_process, stop_owned, wait_owned,
6 },
7 state::ServerState,
8};
9use serde::{Deserialize, Serialize};
10use serde_json::Value;
11use std::{path::PathBuf, time::Duration};
12use tokio_util::sync::CancellationToken;
13
14#[derive(Debug, thiserror::Error)]
15#[error("{0}")]
16pub struct BackendError(pub String);
17impl From<String> for BackendError {
18 fn from(value: String) -> Self {
19 Self(value)
20 }
21}
22#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
23pub enum BackendKind {
24 #[serde(rename = "ollama")]
25 Ollama,
26 #[serde(rename = "llamacpp")]
27 LlamaCpp,
28 #[serde(rename = "bitnet")]
29 BitNet,
30}
31impl BackendKind {
32 pub fn name(self) -> &'static str {
33 match self {
34 Self::Ollama => "ollama",
35 Self::LlamaCpp => "llamacpp",
36 Self::BitNet => "bitnet",
37 }
38 }
39 pub fn port(self) -> u16 {
40 match self {
41 Self::Ollama => 11434,
42 Self::LlamaCpp | Self::BitNet => 8080,
43 }
44 }
45}
46#[derive(Clone)]
47pub struct ServeRequest {
48 pub model_id: String,
49 pub endpoint: String,
50 pub model_path: Option<PathBuf>,
51 pub context: Option<u32>,
52 pub cache: Option<crate::cache::CacheProfile>,
53}
54#[async_trait::async_trait]
55pub trait BackendAdapter: Send + Sync {
56 fn name(&self) -> &'static str;
57 fn trusts(&self, identity: &ProcessIdentity) -> bool;
58 async fn attach_only(
59 &self,
60 _request: &ServeRequest,
61 _cancel: &CancellationToken,
62 ) -> Result<ServerState, BackendError> {
63 Err(BackendError("attach-only operation is unsupported".into()))
64 }
65 fn can_embed(&self) -> bool {
66 matches!(self.name(), "ollama" | "lmstudio")
67 }
68 fn can_stream(&self) -> bool {
69 self.name() == "ollama"
70 }
71 async fn chat(
72 &self,
73 _handle: &ServerState,
74 _input: &crate::ollama_inference::ChatInput,
75 _cancel: &CancellationToken,
76 ) -> Result<crate::ollama_inference::ChatResult, BackendError> {
77 Err(BackendError(
78 "chat is not implemented for this adapter".into(),
79 ))
80 }
81 async fn chat_stream(
82 &self,
83 handle: &ServerState,
84 input: &crate::ollama_inference::ChatInput,
85 cancel: &CancellationToken,
86 on_delta: &mut (dyn for<'chunk> FnMut(&'chunk str) + Send),
87 ) -> Result<crate::ollama_inference::ChatResult, BackendError> {
88 let result = self.chat(handle, input, cancel).await?;
89 on_delta(&result.content);
90 Ok(result)
91 }
92 async fn embed(
93 &self,
94 _handle: &ServerState,
95 _model: &str,
96 _inputs: &[String],
97 _cancel: &CancellationToken,
98 ) -> Result<crate::ollama_inference::EmbedResult, BackendError> {
99 Err(BackendError(
100 "embeddings are unsupported by this adapter".into(),
101 ))
102 }
103 async fn serve(
104 &self,
105 request: &ServeRequest,
106 cancel: &CancellationToken,
107 ) -> Result<ServerState, BackendError>;
108 async fn ready(
109 &self,
110 request: &ServeRequest,
111 cancel: &CancellationToken,
112 ) -> Result<(), BackendError>;
113 async fn stop(
114 &self,
115 handle: &ServerState,
116 cancel: &CancellationToken,
117 ) -> Result<(), BackendError>;
118 async fn ready_handle(
119 &self,
120 request: &ServeRequest,
121 _handle: &ServerState,
122 cancel: &CancellationToken,
123 ) -> Result<(), BackendError> {
124 self.ready(request, cancel).await
125 }
126}
127pub struct RuntimeAdapter<'runtime> {
128 pub kind: BackendKind,
129 pub binary: PathBuf,
130 pub http: &'runtime dyn Transport,
131 pub probe: &'runtime dyn ProcessProbe,
132 pub control: &'runtime dyn ProcessControl,
133 pub(crate) ollama_models: Option<PathBuf>,
134}
135pub fn model_id(value: &str) -> Result<(), BackendError> {
136 if value.is_empty()
137 || value.len() > 8192
138 || !value.as_bytes()[0].is_ascii_alphanumeric()
139 || !value.bytes().all(|byte| {
140 byte.is_ascii_lowercase() || byte.is_ascii_digit() || b"._:/-".contains(&byte)
141 })
142 || value.split('/').any(|part| part == "..")
143 {
144 return Err(BackendError("invalid runtime model id".into()));
145 }
146 Ok(())
147}
148impl<'runtime> RuntimeAdapter<'runtime> {
149 pub fn new(
150 kind: BackendKind,
151 binary: PathBuf,
152 http: &'runtime dyn Transport,
153 probe: &'runtime dyn ProcessProbe,
154 control: &'runtime dyn ProcessControl,
155 ) -> Self {
156 Self {
157 kind,
158 binary,
159 http,
160 probe,
161 control,
162 ollama_models: None,
163 }
164 }
165 pub fn with_ollama_models(mut self, models: PathBuf) -> Result<Self, BackendError> {
166 if self.kind != BackendKind::Ollama {
167 return Err(BackendError(
168 "model store configuration requires Ollama".into(),
169 ));
170 }
171 crate::command::OllamaCommandContext::new("http://127.0.0.1:11434", &models)?;
172 self.ollama_models = Some(models);
173 Ok(self)
174 }
175 async fn json(
176 &self,
177 endpoint: &str,
178 path: &str,
179 cancel: &CancellationToken,
180 ) -> Result<Value, BackendError> {
181 let request = Request::new(endpoint, path, None, None)
182 .map_err(|error| BackendError(error.to_string()))?;
183 tokio::time::timeout(
184 Duration::from_secs(5),
185 read_json(self.http, request, cancel, 4 * 1024 * 1024),
186 )
187 .await
188 .map_err(|_| BackendError("readiness request timed out".into()))?
189 .map_err(|error| BackendError(error.to_string()))
190 }
191 fn validate(&self, request: &ServeRequest) -> Result<url::Url, BackendError> {
192 model_id(&request.model_id)?;
193 if self.kind == BackendKind::BitNet
194 && request
195 .context
196 .is_some_and(|value| !(1..=4096).contains(&value))
197 {
198 return Err(BackendError(
199 "BitNet context must be between 1 and 4096 tokens".into(),
200 ));
201 }
202 if !self.binary.is_absolute()
203 || request
204 .context
205 .is_some_and(|value| !(1..=10000000).contains(&value))
206 {
207 return Err(BackendError("invalid runtime configuration".into()));
208 }
209 crate::state::loopback(&request.endpoint).map_err(|error| BackendError(error.to_string()))
210 }
211 fn gguf_args(
212 &self,
213 request: &ServeRequest,
214 host: &str,
215 port: u16,
216 ) -> Result<Vec<String>, BackendError> {
217 let path = request
218 .model_path
219 .as_ref()
220 .filter(|path| path.is_absolute() && path.is_file())
221 .ok_or_else(|| BackendError("verified absolute GGUF path required".into()))?;
222 let mut args = vec![
223 "-m".into(),
224 path.to_string_lossy().into_owned(),
225 "--host".into(),
226 host.into(),
227 "--port".into(),
228 port.to_string(),
229 "--alias".into(),
230 request.model_id.clone(),
231 ];
232 let context = request
233 .context
234 .or_else(|| (self.kind == BackendKind::BitNet).then_some(4096));
235 if let Some(context) = context {
236 args.extend(["--ctx-size".into(), context.to_string()]);
237 }
238 if self.kind == BackendKind::BitNet {
239 args.extend(["-ngl".into(), "0".into()]);
240 }
241 Ok(args)
242 }
243
244 async fn legacy_bitnet_identity(
245 &self,
246 request: &ServeRequest,
247 props: Value,
248 cancel: &CancellationToken,
249 ) -> Result<(), BackendError> {
250 #[derive(Deserialize)]
251 struct Generation {
252 model: String,
253 n_ctx: u32,
254 }
255 #[derive(Deserialize)]
256 struct Props {
257 default_generation_settings: Generation,
258 total_slots: u32,
259 chat_template: String,
260 }
261 let props: Props = serde_json::from_value(props)
262 .map_err(|_| BackendError("invalid legacy BitNet properties".into()))?;
263 if props.default_generation_settings.model != request.model_id
264 || props.default_generation_settings.n_ctx != request.context.unwrap_or(4096)
265 || props.total_slots != 1
266 || props.chat_template.is_empty()
267 {
268 return Err(BackendError(
269 "legacy BitNet model or context differs".into(),
270 ));
271 }
272 let before = listener(self.probe, &request.endpoint, cancel).await?;
273 if !self.trusts(&before.identity) {
274 return Err(BackendError("untrusted BitNet executable".into()));
275 }
276 let command = self
278 .probe
279 .command_line(before.identity.pid)
280 .await
281 .map_err(|error| BackendError(error.to_string()))?;
282 let mut expected = vec![before.identity.executable.clone()];
283 expected.extend(self.gguf_args(request, &before.address, before.port)?);
284 let after = listener(self.probe, &request.endpoint, cancel).await?;
285 if command != expected || !same_process(&before.identity, &after.identity) {
286 return Err(BackendError("legacy BitNet launch identity differs".into()));
287 }
288 Ok(())
289 }
290
291 async fn ready_once(
292 &self,
293 request: &ServeRequest,
294 cancel: &CancellationToken,
295 ) -> Result<(), BackendError> {
296 self.validate(request)?;
297 match self.kind {
298 BackendKind::Ollama => {
299 let version = self.json(&request.endpoint, "/api/version", cancel).await?;
300 if !version
301 .get("version")
302 .and_then(Value::as_str)
303 .is_some_and(|version| !version.is_empty() && version.len() <= 100)
304 {
305 return Err(BackendError("listener is not Ollama".into()));
306 }
307 crate::ollama_installed::parse_inventory(
308 self.json(&request.endpoint, "/api/tags", cancel).await?,
309 )
310 .map_err(|error| BackendError(error.to_string()))?;
311 }
312 BackendKind::LlamaCpp | BackendKind::BitNet => {
313 let health = self.json(&request.endpoint, "/health", cancel).await?;
314 if health.get("status").and_then(Value::as_str) != Some("ok") {
315 return Err(BackendError("llama.cpp model is not ready".into()));
316 }
317 let props = self.json(&request.endpoint, "/props", cancel).await?;
318 if self.kind == BackendKind::BitNet
319 && props.get("model_path").is_none()
320 && props.get("model_alias").is_none()
321 {
322 return self.legacy_bitnet_identity(request, props, cancel).await;
323 }
324 let path = props.get("model_path").and_then(Value::as_str);
325 let alias = props.get("model_alias").and_then(Value::as_str);
326 if request
327 .model_path
328 .as_ref()
329 .is_some_and(|expected| path != expected.to_str())
330 || alias != Some(request.model_id.as_str())
331 {
332 return Err(BackendError(
333 "llama.cpp loaded artifact or alias differs".into(),
334 ));
335 }
336 }
337 }
338 Ok(())
339 }
340 pub async fn ready(
341 &self,
342 request: &ServeRequest,
343 cancel: &CancellationToken,
344 ) -> Result<(), BackendError> {
345 let operation = async {
346 let mut last = BackendError("runtime is not ready".into());
347 for attempt in 0..20 {
348 match self.ready_once(request, cancel).await {
349 Ok(()) => return Ok(()),
350 Err(error) => last = error,
351 }
352 tokio::time::sleep(Duration::from_millis((100u64 << attempt.min(4)).min(2000)))
353 .await;
354 }
355 Err(last)
356 };
357 tokio::select! {biased;_=cancel.cancelled()=>Err(BackendError("cancelled".into())),result=tokio::time::timeout(Duration::from_secs(30),operation)=>result.map_err(|_|BackendError("runtime readiness timed out".into()))?}
358 }
359 pub async fn serve(
360 &self,
361 request: &ServeRequest,
362 cancel: &CancellationToken,
363 ) -> Result<ServerState, BackendError> {
364 let mut request = request.clone();
365 if self.kind == BackendKind::BitNet {
366 request.context.get_or_insert(4096);
367 }
368 let request = &request;
369 let url = self.validate(request)?;
370 if cancel.is_cancelled() {
371 return Err(BackendError("cancelled".into()));
372 }
373 let occupied = tokio::select! {biased;_=cancel.cancelled()=>return Err(BackendError("cancelled".into())),result=self.control.occupied(&request.endpoint)=>result?};
374 let executable = self
375 .binary
376 .to_str()
377 .ok_or_else(|| BackendError("invalid executable path".into()))?;
378 let (observed, owned) = if occupied {
379 if self.kind == BackendKind::BitNet {
380 return Err(BackendError(
381 "BitNet requires an unused port; refusing to attach to an existing listener"
382 .into(),
383 ));
384 }
385 if crate::cache::effective(request.cache.as_ref()).is_some() {
386 return Err(BackendError(format!(
387 "cache settings apply only to a {} runtime rigspark starts; stop the running server or omit the cache options",
388 self.kind.name()
389 )));
390 }
391 let before = listener(self.probe, &request.endpoint, cancel).await?;
392 if before.identity.executable != executable {
393 return Err(BackendError(
394 "refusing untrusted listener executable".into(),
395 ));
396 }
397 self.ready_once(request, cancel).await?;
398 let after = listener(self.probe, &request.endpoint, cancel).await?;
399 if !same_process(&before.identity, &after.identity) {
400 return Err(BackendError("listener changed during attach".into()));
401 }
402 (after, false)
403 } else {
404 let host = url
405 .host_str()
406 .ok_or_else(|| BackendError("missing runtime host".into()))?
407 .trim_matches(['[', ']']);
408 let port = url
409 .port_or_known_default()
410 .ok_or_else(|| BackendError("missing port".into()))?;
411 let mut env = minimal_env();
412 let delta = crate::cache::launch_delta(request.cache.as_ref(), self.kind.name(), true)
413 .map_err(|error| BackendError(error.to_string()))?;
414 let mut args = match self.kind {
415 BackendKind::Ollama => {
416 if let Some(models) = &self.ollama_models {
417 let context =
418 crate::command::OllamaCommandContext::new(&request.endpoint, models)?;
419 env.extend(context.environment().clone());
420 }
421 env.insert(
422 "OLLAMA_HOST".into(),
423 format!(
424 "{}:{port}",
425 if host.contains(':') {
426 format!("[{host}]")
427 } else {
428 host.into()
429 }
430 ),
431 );
432 vec!["serve".into()]
433 }
434 BackendKind::LlamaCpp | BackendKind::BitNet => {
435 self.gguf_args(request, host, port)?
436 }
437 };
438 args.extend(delta.args);
439 env.extend(delta.env);
440 if cancel.is_cancelled() {
441 return Err(BackendError("cancelled".into()));
442 }
443 let child = self
444 .control
445 .spawn(&SpawnSpec {
446 binary: self.binary.clone(),
447 args,
448 env,
449 })
450 .await?;
451 let observed = wait_owned(
452 child,
453 &request.endpoint,
454 executable,
455 self.probe,
456 cancel,
457 || async { self.ready(request, cancel).await.map_err(|error| error.0) },
458 )
459 .await?;
460 (observed, true)
461 };
462 let state = ServerState {
463 backend: self.kind.name().into(),
464 model_id: request.model_id.clone(),
465 endpoint: request.endpoint.clone(),
466 port: observed.port,
467 owned_by_us: owned,
468 pid: Some(observed.identity.pid),
469 runtime_model_id: None,
470 context: request.context,
471 integrity: None,
472 local_manifest_digest: None,
473 model_path: if self.kind == BackendKind::BitNet {
474 request
475 .model_path
476 .as_ref()
477 .map(|path| path.to_string_lossy().into_owned())
478 } else {
479 None
480 },
481 process_executable: Some(observed.identity.executable),
482 process_started_at: Some(observed.identity.started),
483 auth_token: None,
484 cache: if owned {
485 crate::cache::effective(request.cache.as_ref())
486 } else {
487 None
488 },
489 };
490 state
491 .validate()
492 .map_err(|error| BackendError(error.to_string()))?;
493 Ok(state)
494 }
495 pub async fn stop(
496 &self,
497 handle: &ServerState,
498 cancel: &CancellationToken,
499 ) -> Result<(), BackendError> {
500 handle
501 .validate()
502 .map_err(|error| BackendError(error.to_string()))?;
503 if handle.backend != self.kind.name() {
504 return Err(BackendError("backend handle mismatch".into()));
505 }
506 if !handle.owned_by_us {
507 return Ok(());
508 }
509 let expected = ProcessIdentity {
510 pid: handle
511 .pid
512 .ok_or_else(|| BackendError("missing PID".into()))?,
513 process: String::new(),
514 executable: handle
515 .process_executable
516 .clone()
517 .ok_or_else(|| BackendError("missing executable identity".into()))?,
518 started: handle
519 .process_started_at
520 .clone()
521 .ok_or_else(|| BackendError("missing start identity".into()))?,
522 };
523 if self.binary.to_str() != Some(&expected.executable) {
524 return Err(BackendError("untrusted stop executable".into()));
525 }
526 stop_owned(
527 &handle.endpoint,
528 &expected,
529 self.probe,
530 self.control,
531 cancel,
532 )
533 .await
534 .map_err(BackendError)
535 }
536}
537#[async_trait::async_trait]
538impl BackendAdapter for RuntimeAdapter<'_> {
539 async fn attach_only(
540 &self,
541 request: &ServeRequest,
542 cancel: &CancellationToken,
543 ) -> Result<ServerState, BackendError> {
544 if self.kind == BackendKind::BitNet {
545 return Err(BackendError(
546 "BitNet requires an owned server; use up".into(),
547 ));
548 }
549 self.validate(request)?;
550 if cancel.is_cancelled() {
551 return Err(BackendError("cancelled".into()));
552 }
553 if !self.control.occupied(&request.endpoint).await? {
554 return Err(BackendError(
555 "existing runtime required; refusing to spawn".into(),
556 ));
557 }
558 let before = listener(self.probe, &request.endpoint, cancel).await?;
559 if !self.trusts(&before.identity) {
560 return Err(BackendError("untrusted attached executable".into()));
561 }
562 self.ready_once(request, cancel).await?;
563 let after = listener(self.probe, &request.endpoint, cancel).await?;
564 if !same_process(&before.identity, &after.identity) {
565 return Err(BackendError("listener changed during attachment".into()));
566 }
567 let state=crate::state::RuntimeState::parse(&serde_json::json!({"schemaVersion":2,"active":{"backend":self.name(),"modelId":request.model_id,"endpoint":request.endpoint,"port":after.port,"ownedByUs":false,"pid":after.identity.pid,"processExecutable":after.identity.executable,"processStartedAt":after.identity.started}}).to_string()).map_err(|error|BackendError(error.to_string()))?;
568 state
569 .active
570 .ok_or_else(|| BackendError("missing attached state".into()))
571 }
572 async fn ready_handle(
573 &self,
574 request: &ServeRequest,
575 handle: &ServerState,
576 cancel: &CancellationToken,
577 ) -> Result<(), BackendError> {
578 handle
579 .validate()
580 .map_err(|error| BackendError(error.to_string()))?;
581 if handle.backend != self.name() || handle.endpoint != request.endpoint {
582 return Err(BackendError("readiness handle mismatch".into()));
583 }
584 if self.kind == BackendKind::BitNet
585 && (handle.model_id != request.model_id
586 || handle.model_path.as_deref()
587 != request.model_path.as_ref().and_then(|path| path.to_str())
588 || handle.context != Some(request.context.unwrap_or(4096)))
589 {
590 return Err(BackendError(
591 "BitNet readiness model or context mismatch".into(),
592 ));
593 }
594 let before = listener(self.probe, &handle.endpoint, cancel).await?;
595 crate::identity::capture(handle, &before, self.trusts(&before.identity))
596 .map_err(|error| BackendError(error.to_string()))?;
597 self.ready(request, cancel).await?;
598 let models = self.json(&handle.endpoint, "/v1/models", cancel).await?;
599 #[derive(Deserialize)]
600 struct Model {
601 id: String,
602 }
603 #[derive(Deserialize)]
604 struct Models {
605 data: Vec<Model>,
606 }
607 let models: Models = serde_json::from_value(models)
608 .map_err(|_| BackendError("invalid OpenAI models response".into()))?;
609 if models.data.len() > 10000
610 || models
611 .data
612 .iter()
613 .any(|model| model.id.is_empty() || model.id.len() > 8192)
614 {
615 return Err(BackendError("invalid OpenAI models".into()));
616 }
617 let after = listener(self.probe, &handle.endpoint, cancel).await?;
618 if !same_process(&before.identity, &after.identity) {
619 return Err(BackendError("readiness listener changed".into()));
620 }
621 Ok(())
622 }
623 fn name(&self) -> &'static str {
624 self.kind.name()
625 }
626 fn trusts(&self, identity: &ProcessIdentity) -> bool {
627 self.binary.to_str() == Some(identity.executable.as_str())
628 }
629 async fn chat(
630 &self,
631 handle: &ServerState,
632 input: &crate::ollama_inference::ChatInput,
633 cancel: &CancellationToken,
634 ) -> Result<crate::ollama_inference::ChatResult, BackendError> {
635 if matches!(self.kind, BackendKind::LlamaCpp | BackendKind::BitNet) {
636 return crate::openai::OpenAiInference {
637 http: self.http,
638 probe: self.probe,
639 adapter: self,
640 token: None,
641 }
642 .chat(handle, input, cancel)
643 .await;
644 }
645 let expected = expected_process(handle)?;
646 let mut input = input.clone();
647 input.model = handle.runtime_model_id.clone().unwrap_or(input.model);
648 crate::ollama_inference::OllamaInference::new(
649 self.http,
650 self.probe,
651 self.binary
652 .to_str()
653 .ok_or_else(|| BackendError("invalid executable".into()))?,
654 )
655 .chat(&handle.endpoint, &expected, &input, cancel)
656 .await
657 .map_err(|error| BackendError(error.to_string()))
658 }
659 async fn chat_stream(
660 &self,
661 handle: &ServerState,
662 input: &crate::ollama_inference::ChatInput,
663 cancel: &CancellationToken,
664 on_delta: &mut (dyn for<'chunk> FnMut(&'chunk str) + Send),
665 ) -> Result<crate::ollama_inference::ChatResult, BackendError> {
666 if matches!(self.kind, BackendKind::LlamaCpp | BackendKind::BitNet) {
667 let result = self.chat(handle, input, cancel).await?;
668 on_delta(&result.content);
669 return Ok(result);
670 }
671 let expected = expected_process(handle)?;
672 let mut input = input.clone();
673 input.model = handle.runtime_model_id.clone().unwrap_or(input.model);
674 crate::ollama_inference::OllamaInference::new(
675 self.http,
676 self.probe,
677 self.binary
678 .to_str()
679 .ok_or_else(|| BackendError("invalid executable".into()))?,
680 )
681 .chat_stream(&handle.endpoint, &expected, &input, cancel, on_delta)
682 .await
683 .map_err(|error| BackendError(error.to_string()))
684 }
685 async fn embed(
686 &self,
687 handle: &ServerState,
688 model: &str,
689 inputs: &[String],
690 cancel: &CancellationToken,
691 ) -> Result<crate::ollama_inference::EmbedResult, BackendError> {
692 if self.kind != BackendKind::Ollama {
693 return Err(BackendError(format!(
694 "{} does not serve embeddings",
695 self.name()
696 )));
697 }
698 let expected = expected_process(handle)?;
699 crate::ollama_inference::OllamaInference::new(
700 self.http,
701 self.probe,
702 self.binary
703 .to_str()
704 .ok_or_else(|| BackendError("invalid executable".into()))?,
705 )
706 .embed(&handle.endpoint, &expected, model, inputs, cancel)
707 .await
708 .map_err(|error| BackendError(error.to_string()))
709 }
710 async fn serve(
711 &self,
712 request: &ServeRequest,
713 cancel: &CancellationToken,
714 ) -> Result<ServerState, BackendError> {
715 RuntimeAdapter::serve(self, request, cancel).await
716 }
717 async fn ready(
718 &self,
719 request: &ServeRequest,
720 cancel: &CancellationToken,
721 ) -> Result<(), BackendError> {
722 RuntimeAdapter::ready(self, request, cancel).await
723 }
724 async fn stop(
725 &self,
726 handle: &ServerState,
727 cancel: &CancellationToken,
728 ) -> Result<(), BackendError> {
729 RuntimeAdapter::stop(self, handle, cancel).await
730 }
731}
732fn expected_process(handle: &ServerState) -> Result<ProcessIdentity, BackendError> {
733 handle
734 .validate()
735 .map_err(|error| BackendError(error.to_string()))?;
736 if handle.backend != "ollama" {
737 return Err(BackendError("Ollama handle required".into()));
738 }
739 Ok(ProcessIdentity {
740 pid: handle
741 .pid
742 .ok_or_else(|| BackendError("expected PID required".into()))?,
743 process: String::new(),
744 executable: handle
745 .process_executable
746 .clone()
747 .ok_or_else(|| BackendError("expected executable required".into()))?,
748 started: handle
749 .process_started_at
750 .clone()
751 .ok_or_else(|| BackendError("expected start identity required".into()))?,
752 })
753}