Skip to main content

rigspark_runtime/
adapters.rs

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        // Older BitNet exposes only an alias over HTTP; prove the exact model launch via the OS.
277        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}