longbridge 4.5.0

Longbridge OpenAPI SDK for Rust
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
129
130

use std::{pin::Pin, sync::Arc};

use futures_util::Stream;
use tokio::sync::mpsc;

use crate::{
    Config, Result,
    agent::{self, AgentContext, types::*},
    blocking::runtime::BlockingRuntime,
};

/// Blocking AI Agent conversation context.
pub struct AgentContextSync {
    rt: BlockingRuntime<AgentContext>,
}

impl AgentContextSync {
    /// Create an [`AgentContextSync`]
    pub fn new(config: Arc<Config>) -> Result<Self> {
        let rt = BlockingRuntime::try_new(
            move || {
                let ctx = AgentContext::new(config);
                let (tx, rx) = mpsc::unbounded_channel::<std::convert::Infallible>();
                std::mem::forget(tx);
                Ok::<_, crate::Error>((ctx, rx))
            },
            |_: std::convert::Infallible| {},
        )?;
        Ok(Self { rt })
    }

    /// List the Workspaces the current account belongs to.
    pub fn workspaces(&self) -> Result<WorkspacesResponse> {
        self.rt
            .call(move |ctx| async move { ctx.workspaces().await })
    }

    /// List the Agents in the specified Workspace.
    pub fn agents(
        &self,
        workspace_id: impl Into<String> + Send + 'static,
        opts: impl Into<Option<GetAgentsOptions>> + Send + 'static,
    ) -> Result<AgentsResponse> {
        self.rt
            .call(move |ctx| async move { ctx.agents(workspace_id, opts).await })
    }

    /// List all publicly available Agents on the platform.
    pub fn public_agents(
        &self,
        opts: impl Into<Option<GetAgentsOptions>> + Send + 'static,
    ) -> Result<AgentsResponse> {
        self.rt
            .call(move |ctx| async move { ctx.public_agents(opts).await })
    }

    /// Start a conversation with the specified Agent, blocking until the run
    /// succeeds, is interrupted, or fails.
    pub fn conversation(
        &self,
        agent_id: impl Into<String> + Send + 'static,
        query: impl Into<String> + Send + 'static,
        chat_uid: Option<String>,
        parent_message_id: Option<String>,
    ) -> Result<ConversationResponse> {
        self.rt.call(move |ctx| async move {
            ctx.conversation(agent_id, query, chat_uid, parent_message_id)
                .await
        })
    }

    /// Resume an interrupted conversation, blocking until the run succeeds, is
    /// interrupted again, or fails.
    pub fn continue_conversation(
        &self,
        agent_id: impl Into<String> + Send + 'static,
        chat_uid: impl Into<String> + Send + 'static,
        message_id: impl Into<String> + Send + 'static,
        answers: AnswersByToolCall,
    ) -> Result<ConversationResponse> {
        self.rt.call(move |ctx| async move {
            ctx.continue_conversation(agent_id, chat_uid, message_id, answers)
                .await
        })
    }

    /// Start a conversation with the specified Agent, returning a blocking
    /// [`agent::ConversationStreamIter`] of run-progress events.
    pub fn conversation_streamed(
        &self,
        agent_id: impl Into<String> + Send + 'static,
        query: impl Into<String> + Send + 'static,
        chat_uid: Option<String>,
        parent_message_id: Option<String>,
    ) -> Result<agent::ConversationStreamIter> {
        let stream = self.rt.call(move |ctx| async move {
            // Box the RPIT stream so it can flow through `rt.call`'s generic
            // `R: Send + 'static`.
            Ok(Box::pin(
                ctx.conversation_streamed(agent_id, query, chat_uid, parent_message_id)
                    .await?,
            )
                as Pin<
                    Box<dyn Stream<Item = Result<ConversationStreamEvent>> + Send>,
                >)
        })?;
        Ok(agent::conversation_stream_iter(stream))
    }

    /// Resume an interrupted conversation, returning a blocking
    /// [`agent::ConversationStreamIter`] of run-progress events.
    pub fn continue_conversation_streamed(
        &self,
        agent_id: impl Into<String> + Send + 'static,
        chat_uid: impl Into<String> + Send + 'static,
        message_id: impl Into<String> + Send + 'static,
        answers: AnswersByToolCall,
    ) -> Result<agent::ConversationStreamIter> {
        let stream = self.rt.call(move |ctx| async move {
            Ok(Box::pin(
                ctx.continue_conversation_streamed(agent_id, chat_uid, message_id, answers)
                    .await?,
            )
                as Pin<
                    Box<dyn Stream<Item = Result<ConversationStreamEvent>> + Send>,
                >)
        })?;
        Ok(agent::conversation_stream_iter(stream))
    }
}