gproxy_protocol/adapt/generate/stream/prepare/
chat_claude.rs

1use std::future::Future;
2
3use super::super::super::{
4    Endpoint, GenerationIdentity, GenerationResources, GenerationStateAccess,
5    chat_claude::{ChatViaClaude, ClaudeViaChat},
6};
7use super::super::{StreamInvocation, StreamSettings, StreamTarget};
8use super::{RequestMode, start};
9use crate::{
10    capability::{ResourceAccess, StateStore},
11    transform::{TransformError, generate::claude_chat::stream as p},
12    wire::{DeclaredFields, claude::generate_content as c, openai::chat as h},
13};
14
15impl ChatViaClaude {
16    pub async fn prepare_stream<S: StateStore>(
17        input: h::GenerateContentRequestBody,
18        target: StreamTarget,
19        context: p::ClaudeToChatContext,
20        settings: StreamSettings,
21        state: &GenerationStateAccess<'_, S>,
22    ) -> Result<StreamInvocation<p::ClaudeToChatStream>, TransformError> {
23        Self::stream(
24            input,
25            target,
26            context,
27            settings,
28            state,
29            |input, endpoint, ids| Self::prepare_with_state(input, endpoint, ids, state),
30        )
31        .await
32    }
33    pub async fn prepare_stream_with_capabilities<S: StateStore, R: ResourceAccess>(
34        input: h::GenerateContentRequestBody,
35        target: StreamTarget,
36        context: p::ClaudeToChatContext,
37        settings: StreamSettings,
38        state: &GenerationStateAccess<'_, S>,
39        resources: &GenerationResources<'_, R>,
40    ) -> Result<StreamInvocation<p::ClaudeToChatStream>, TransformError> {
41        Self::stream(
42            input,
43            target,
44            context,
45            settings,
46            state,
47            |input, endpoint, ids| {
48                Self::prepare_with_capabilities(input, endpoint, ids, state, resources)
49            },
50        )
51        .await
52    }
53    async fn stream<S: StateStore, Fut: Future<Output = Result<Self, TransformError>>>(
54        input: h::GenerateContentRequestBody,
55        target: StreamTarget,
56        context: p::ClaudeToChatContext,
57        settings: StreamSettings,
58        state: &GenerationStateAccess<'_, S>,
59        prepare: impl FnOnce(h::GenerateContentRequestBody, Endpoint, GenerationIdentity) -> Fut,
60    ) -> Result<StreamInvocation<p::ClaudeToChatStream>, TransformError> {
61        let original = input.into_declared();
62        let prepared = prepare(
63            original.clone().buffered(),
64            target.endpoint.clone(),
65            target.identities.clone(),
66        )
67        .await?;
68        start(
69            original,
70            prepared,
71            target,
72            settings,
73            state,
74            |_, target, settings| {
75                p::ClaudeToChatStream::new_with_policy(
76                    context,
77                    target.identities.response.clone(),
78                    settings.events.into(),
79                    target.identities.response_policy.clone(),
80                )
81            },
82        )
83        .await
84    }
85}
86
87impl ClaudeViaChat {
88    pub async fn prepare_stream<S: StateStore>(
89        input: c::GenerateContentRequestBody,
90        target: StreamTarget,
91        context: p::ChatToClaudeContext,
92        settings: StreamSettings,
93        state: &GenerationStateAccess<'_, S>,
94    ) -> Result<StreamInvocation<p::ChatToClaudeStream>, TransformError> {
95        Self::stream(
96            input,
97            target,
98            context,
99            settings,
100            state,
101            |input, endpoint, ids| Self::prepare_with_state(input, endpoint, ids, state),
102        )
103        .await
104    }
105    pub async fn prepare_stream_with_capabilities<S: StateStore, R: ResourceAccess>(
106        input: c::GenerateContentRequestBody,
107        target: StreamTarget,
108        context: p::ChatToClaudeContext,
109        settings: StreamSettings,
110        state: &GenerationStateAccess<'_, S>,
111        resources: &GenerationResources<'_, R>,
112    ) -> Result<StreamInvocation<p::ChatToClaudeStream>, TransformError> {
113        Self::stream(
114            input,
115            target,
116            context,
117            settings,
118            state,
119            |input, endpoint, ids| {
120                Self::prepare_with_capabilities(input, endpoint, ids, state, resources)
121            },
122        )
123        .await
124    }
125    async fn stream<S: StateStore, Fut: Future<Output = Result<Self, TransformError>>>(
126        input: c::GenerateContentRequestBody,
127        target: StreamTarget,
128        context: p::ChatToClaudeContext,
129        settings: StreamSettings,
130        state: &GenerationStateAccess<'_, S>,
131        prepare: impl FnOnce(c::GenerateContentRequestBody, Endpoint, GenerationIdentity) -> Fut,
132    ) -> Result<StreamInvocation<p::ChatToClaudeStream>, TransformError> {
133        let original = input.into_declared();
134        let prepared = prepare(
135            original.clone().buffered(),
136            target.endpoint.clone(),
137            target.identities.clone(),
138        )
139        .await?;
140        start(
141            original,
142            prepared,
143            target,
144            settings,
145            state,
146            |_, target, settings| {
147                p::ChatToClaudeStream::new_with_policy(
148                    context,
149                    target.identities.response.clone(),
150                    settings.events.into(),
151                    target.identities.response_policy.clone(),
152                )
153            },
154        )
155        .await
156    }
157}
gproxy_protocol/adapt/generate/stream/prepare/chat_claude.rs

gproxy_protocol/adapt/generate/stream/prepare/
chat_claude.rs
