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