browsing 0.1.4

Lightweight MCP/API for browser automation: navigate, get content (text), screenshot. Parallelism via RwLock.
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

//! Base traits for LLM chat models

use crate::error::Result;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};

/// Chat message for LLM communication
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessage {
    /// Role of the message sender (user, assistant, system)
    pub role: String,
    /// Content of the message
    pub content: String,
}

impl ChatMessage {
    /// Creates a new chat message
    pub fn new(role: String, content: String) -> Self {
        Self { role, content }
    }

    /// Creates a user message
    pub fn user(content: String) -> Self {
        Self {
            role: "user".to_string(),
            content,
        }
    }

    /// Creates an assistant message
    pub fn assistant(content: String) -> Self {
        Self {
            role: "assistant".to_string(),
            content,
        }
    }

    /// Creates a system message
    pub fn system(content: String) -> Self {
        Self {
            role: "system".to_string(),
            content,
        }
    }
}

/// Chat model trait for LLM integration
#[async_trait]
pub trait ChatModel: Send + Sync {
    /// Get the model name
    fn model(&self) -> &str;

    /// Get the provider name
    fn provider(&self) -> &str;

    /// Get the model name (alias for model)
    fn name(&self) -> &str {
        self.model()
    }

    /// Chat with the model (non-streaming)
    async fn chat(&self, messages: &[ChatMessage]) -> Result<ChatInvokeCompletion<String>>;

    /// Chat with the model (streaming)
    async fn chat_stream(
        &self,
        messages: &[ChatMessage],
    ) -> Result<Box<dyn futures_util::stream::Stream<Item = Result<String>> + Send + Unpin>>;
}

/// Usage information for a chat model invocation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatInvokeUsage {
    /// Number of prompt tokens used
    pub prompt_tokens: u32,
    /// Number of cached prompt tokens
    pub prompt_cached_tokens: Option<u32>,
    /// Number of tokens used to create prompt cache
    pub prompt_cache_creation_tokens: Option<u32>,
    /// Number of tokens used for images
    pub prompt_image_tokens: Option<u32>,
    /// Number of completion tokens used
    pub completion_tokens: u32,
    /// Total number of tokens used
    pub total_tokens: u32,
}

/// Response from a chat model invocation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatInvokeCompletion<T> {
    /// The completion content
    pub completion: T,
    /// Thinking process of the model
    pub thinking: Option<String>,
    /// Redacted thinking content
    pub redacted_thinking: Option<String>,
    /// Token usage information
    pub usage: Option<ChatInvokeUsage>,
    /// Reason for stopping
    pub stop_reason: Option<String>,
}

impl<T> ChatInvokeCompletion<T> {
    /// Creates a new completion
    pub fn new(completion: T) -> Self {
        Self {
            completion,
            thinking: None,
            redacted_thinking: None,
            usage: None,
            stop_reason: None,
        }
    }

    /// Sets the usage information
    pub fn with_usage(mut self, usage: ChatInvokeUsage) -> Self {
        self.usage = Some(usage);
        self
    }
}