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

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

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