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 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 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}