api_ollama 0.2.0

Ollama local LLM runtime API client for HTTP communication.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! OllamaClient retry methods extension.
//!
//! Explicit retry methods for API operations.

#[ cfg( feature = "retry" ) ]
mod private
{
  use crate::client::OllamaClient;
  use crate::{ OllamaResult, ChatRequest, ChatResponse, GenerateRequest, GenerateResponse, TagsResponse, ModelInfo };

  impl OllamaClient
  {
    #[ cfg( feature = "retry" ) ]
    /// Execute chat request with retry logic (explicit retry method)
    pub async fn chat_with_retries( &mut self, request : ChatRequest ) -> OllamaResult< ChatResponse >
    {
      match &self.retry_client
      {
        Some( retry_client ) =>
        {
          let chat_operation = ||
          {
            let req = request.clone();
            let client_clone = self.clone();
            Box::pin( async move
            {
              let mut client = client_clone;
              client.chat( req ).await
            } ) as std::pin::Pin< Box< dyn std::future::Future< Output = OllamaResult< ChatResponse > > + Send > >
          };

          retry_client.execute( chat_operation ).await
        }
        None =>
        {
          // No retry configured, execute normally
          self.chat( request ).await
        }
      }
    }

    #[ cfg( feature = "retry" ) ]
    /// Execute generate request with retry logic (explicit retry method)
    pub async fn generate_with_retries( &mut self, request : GenerateRequest ) -> OllamaResult< GenerateResponse >
    {
      match &self.retry_client
      {
        Some( retry_client ) =>
        {
          let generate_operation = ||
          {
            let req = request.clone();
            let client_clone = self.clone();
            Box::pin( async move
            {
              let mut client = client_clone;
              client.generate( req ).await
            } ) as std::pin::Pin< Box< dyn std::future::Future< Output = OllamaResult< GenerateResponse > > + Send > >
          };

          retry_client.execute( generate_operation ).await
        }
        None =>
        {
          // No retry configured, execute normally
          self.generate( request ).await
        }
      }
    }

    #[ cfg( feature = "retry" ) ]
    /// Execute list models request with retry logic (explicit retry method)
    pub async fn list_models_with_retries( &mut self ) -> OllamaResult< TagsResponse >
    {
      match &self.retry_client
      {
        Some( retry_client ) =>
        {
          let list_models_operation = ||
          {
            let client_clone = self.clone();
            Box::pin( async move
            {
              let mut client = client_clone;
              client.list_models().await
            } ) as std::pin::Pin< Box< dyn std::future::Future< Output = OllamaResult< TagsResponse > > + Send > >
          };

          retry_client.execute( list_models_operation ).await
        }
        None =>
        {
          // No retry configured, execute normally
          self.list_models().await
        }
      }
    }

    #[ cfg( feature = "retry" ) ]
    /// Execute model info request with retry logic (explicit retry method)
    pub async fn model_info_with_retries( &mut self, model_name : String ) -> OllamaResult< ModelInfo >
    {
      match &self.retry_client
      {
        Some( retry_client ) =>
        {
          let model_info_operation = ||
          {
            let name = model_name.clone();
            let client_clone = self.clone();
            Box::pin( async move
            {
              let mut client = client_clone;
              client.model_info( name ).await
            } ) as std::pin::Pin< Box< dyn std::future::Future< Output = OllamaResult< ModelInfo > > + Send > >
          };

          retry_client.execute( model_info_operation ).await
        }
        None =>
        {
          // No retry configured, execute normally
          self.model_info( model_name ).await
        }
      }
    }
  }
}