vis-agent 0.5.22.dev9332__py3-none-any.whl → 0.5.22.dev9358__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- blockether/vis/_contracts.py +1 -0
- blockether/vis/_data/fixtures/gateway-answers.json +198 -0
- blockether/vis/_data/schema/content.json +68 -0
- blockether/vis/_data/schema/gateway.json +831 -2
- blockether/vis/_data/schema/voice.json +737 -0
- blockether/vis/_outside.py +1 -1
- blockether/vis/engine/__init__.py +5 -4
- blockether/vis/engine/_agent.py +34 -17
- blockether/vis/engine/_client.py +72 -2585
- blockether/vis/engine/_extensions.py +3 -3
- blockether/vis/engine/_groups.py +1 -1
- blockether/vis/engine/_host.py +4 -4
- blockether/vis/engine/_local.py +8 -8
- blockether/vis/engine/_routes.py +2662 -0
- blockether/vis/engine/_sounds.py +11 -9
- blockether/vis/engine/_speech.py +18 -16
- blockether/vis/engine/_types.py +385 -40
- blockether/vis/engine/release-tag +1 -1
- blockether/vis/extension.py +7 -11
- {vis_agent-0.5.22.dev9332.dist-info → vis_agent-0.5.22.dev9358.dist-info}/METADATA +1 -1
- {vis_agent-0.5.22.dev9332.dist-info → vis_agent-0.5.22.dev9358.dist-info}/RECORD +23 -21
- {vis_agent-0.5.22.dev9332.dist-info → vis_agent-0.5.22.dev9358.dist-info}/WHEEL +0 -0
- {vis_agent-0.5.22.dev9332.dist-info → vis_agent-0.5.22.dev9358.dist-info}/licenses/LICENSE +0 -0
|
@@ -0,0 +1,2662 @@
|
|
|
1
|
+
"""The gateway routes of the SDK as methods, one for each route operation.
|
|
2
|
+
|
|
3
|
+
`EngineClient.routes` gives the `Routes` object of a client. `EngineClient` and
|
|
4
|
+
its session handles hold the workflow API and call these methods.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from __future__ import annotations
|
|
8
|
+
|
|
9
|
+
from collections.abc import Mapping
|
|
10
|
+
from typing import TYPE_CHECKING, TypeAlias
|
|
11
|
+
|
|
12
|
+
from blockether.vis.engine import _types
|
|
13
|
+
from blockether.vis.engine._types import JSONValue
|
|
14
|
+
|
|
15
|
+
if TYPE_CHECKING:
|
|
16
|
+
from ._client import EngineClient, Response
|
|
17
|
+
|
|
18
|
+
Query: TypeAlias = Mapping[str, str | int | float | bool | None]
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
class Routes:
|
|
22
|
+
"""One method for each gateway route that the SDK can call.
|
|
23
|
+
|
|
24
|
+
Get it from `EngineClient.routes`. Each method sends one request and returns
|
|
25
|
+
the parsed answer. The method name is the HTTP method and the route. `body`
|
|
26
|
+
and `query` use the wire schema of the gateway, not Python objects. For
|
|
27
|
+
ordinary workflows, use `EngineClient`, `Session` and `Turn` methods.
|
|
28
|
+
|
|
29
|
+
A route failure raises `GatewayError`. An IO failure or a malformed answer
|
|
30
|
+
raises `TransportError` or a subclass. A mutation is sent one time only.
|
|
31
|
+
The streamed model upload is `GatewayClient.post_decision_model`, because
|
|
32
|
+
only HTTP can stream a request body.
|
|
33
|
+
|
|
34
|
+
```python
|
|
35
|
+
from blockether.vis.engine import GatewayClient
|
|
36
|
+
|
|
37
|
+
with GatewayClient("http://127.0.0.1:7890") as client:
|
|
38
|
+
usage = client.routes.get_session_usage("session-id")
|
|
39
|
+
print(usage)
|
|
40
|
+
```
|
|
41
|
+
"""
|
|
42
|
+
|
|
43
|
+
def __init__(self, client: EngineClient):
|
|
44
|
+
self._client = client
|
|
45
|
+
|
|
46
|
+
def put_session_client_extensions(
|
|
47
|
+
self, sid: str, *, body: JSONValue, timeout: float | None = None
|
|
48
|
+
) -> _types.EmptyObject:
|
|
49
|
+
"""PUT /v1/sessions/:sid/client-extensions — bind client-owned declarations."""
|
|
50
|
+
return self._client._request(
|
|
51
|
+
"PUT",
|
|
52
|
+
"/v1/sessions/:sid/client-extensions",
|
|
53
|
+
path={"sid": sid},
|
|
54
|
+
body=body,
|
|
55
|
+
timeout=timeout,
|
|
56
|
+
).json()
|
|
57
|
+
|
|
58
|
+
def delete_session_client_extensions(
|
|
59
|
+
self, sid: str, *, timeout: float | None = None
|
|
60
|
+
) -> _types.EmptyObject:
|
|
61
|
+
"""DELETE /v1/sessions/:sid/client-extensions — detach owned callbacks."""
|
|
62
|
+
return self._client._request(
|
|
63
|
+
"DELETE",
|
|
64
|
+
"/v1/sessions/:sid/client-extensions",
|
|
65
|
+
path={"sid": sid},
|
|
66
|
+
timeout=timeout,
|
|
67
|
+
).json()
|
|
68
|
+
|
|
69
|
+
def get_session_client_calls(
|
|
70
|
+
self, sid: str, *, timeout: float | None = None
|
|
71
|
+
) -> _types.ClientCalls:
|
|
72
|
+
"""GET /v1/sessions/:sid/client-calls — retrieve pending owned calls."""
|
|
73
|
+
return self._client._request(
|
|
74
|
+
"GET",
|
|
75
|
+
"/v1/sessions/:sid/client-calls",
|
|
76
|
+
path={"sid": sid},
|
|
77
|
+
timeout=timeout,
|
|
78
|
+
).json()
|
|
79
|
+
|
|
80
|
+
def post_session_client_call_result(
|
|
81
|
+
self, sid: str, call_id: str, *, body: JSONValue, timeout: float | None = None
|
|
82
|
+
) -> _types.EmptyObject:
|
|
83
|
+
"""POST /v1/sessions/:sid/client-calls/:call_id/result — acknowledge one call."""
|
|
84
|
+
return self._client._request(
|
|
85
|
+
"POST",
|
|
86
|
+
"/v1/sessions/:sid/client-calls/:call_id/result",
|
|
87
|
+
path={"sid": sid, "call_id": call_id},
|
|
88
|
+
body=body,
|
|
89
|
+
timeout=timeout,
|
|
90
|
+
).json()
|
|
91
|
+
|
|
92
|
+
def post_session_client_call_activity(
|
|
93
|
+
self, sid: str, call_id: str, *, body: JSONValue, timeout: float | None = None
|
|
94
|
+
) -> _types.EmptyObject:
|
|
95
|
+
"""POST /v1/sessions/:sid/client-calls/:call_id/activity — publish presentation."""
|
|
96
|
+
return self._client._request(
|
|
97
|
+
"POST",
|
|
98
|
+
"/v1/sessions/:sid/client-calls/:call_id/activity",
|
|
99
|
+
path={"sid": sid, "call_id": call_id},
|
|
100
|
+
body=body,
|
|
101
|
+
timeout=timeout,
|
|
102
|
+
).json()
|
|
103
|
+
|
|
104
|
+
def get_capabilities(
|
|
105
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
106
|
+
) -> _types.Capabilities:
|
|
107
|
+
"""GET /v1/capabilities — json response."""
|
|
108
|
+
response = self._client._request(
|
|
109
|
+
"GET", "/v1/capabilities", path={}, query=query, timeout=timeout
|
|
110
|
+
)
|
|
111
|
+
return response.json()
|
|
112
|
+
|
|
113
|
+
def get_devices(
|
|
114
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
115
|
+
) -> _types.Devices:
|
|
116
|
+
"""GET /v1/devices — json response."""
|
|
117
|
+
response = self._client._request(
|
|
118
|
+
"GET", "/v1/devices", path={}, query=query, timeout=timeout
|
|
119
|
+
)
|
|
120
|
+
return response.json()
|
|
121
|
+
|
|
122
|
+
def post_devices(
|
|
123
|
+
self,
|
|
124
|
+
*,
|
|
125
|
+
query: Query | None = None,
|
|
126
|
+
timeout: float | None = None,
|
|
127
|
+
body: JSONValue = None,
|
|
128
|
+
) -> _types.DeviceRegistered:
|
|
129
|
+
"""POST /v1/devices — json response."""
|
|
130
|
+
response = self._client._request(
|
|
131
|
+
"POST", "/v1/devices", path={}, query=query, timeout=timeout, body=body
|
|
132
|
+
)
|
|
133
|
+
return response.json()
|
|
134
|
+
|
|
135
|
+
def delete_device(
|
|
136
|
+
self, token: str, *, query: Query | None = None, timeout: float | None = None
|
|
137
|
+
) -> _types.Removed:
|
|
138
|
+
"""DELETE /v1/devices/:token — json response."""
|
|
139
|
+
response = self._client._request(
|
|
140
|
+
"DELETE",
|
|
141
|
+
"/v1/devices/:token",
|
|
142
|
+
path={"token": token},
|
|
143
|
+
query=query,
|
|
144
|
+
timeout=timeout,
|
|
145
|
+
)
|
|
146
|
+
return response.json()
|
|
147
|
+
|
|
148
|
+
def post_devices_test(
|
|
149
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
150
|
+
) -> _types.DeviceTest:
|
|
151
|
+
"""POST /v1/devices/actions/test — json response."""
|
|
152
|
+
response = self._client._request(
|
|
153
|
+
"POST", "/v1/devices/actions/test", path={}, query=query, timeout=timeout
|
|
154
|
+
)
|
|
155
|
+
return response.json()
|
|
156
|
+
|
|
157
|
+
def get_fs(
|
|
158
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
159
|
+
) -> _types.FsListing:
|
|
160
|
+
"""GET /v1/fs — json response."""
|
|
161
|
+
response = self._client._request(
|
|
162
|
+
"GET", "/v1/fs", path={}, query=query, timeout=timeout
|
|
163
|
+
)
|
|
164
|
+
return response.json()
|
|
165
|
+
|
|
166
|
+
def post_fs_mkdir(
|
|
167
|
+
self,
|
|
168
|
+
*,
|
|
169
|
+
query: Query | None = None,
|
|
170
|
+
timeout: float | None = None,
|
|
171
|
+
body: JSONValue = None,
|
|
172
|
+
) -> _types.FsEntry:
|
|
173
|
+
"""POST /v1/fs/actions/mkdir — json response."""
|
|
174
|
+
response = self._client._request(
|
|
175
|
+
"POST",
|
|
176
|
+
"/v1/fs/actions/mkdir",
|
|
177
|
+
path={},
|
|
178
|
+
query=query,
|
|
179
|
+
timeout=timeout,
|
|
180
|
+
body=body,
|
|
181
|
+
)
|
|
182
|
+
return response.json()
|
|
183
|
+
|
|
184
|
+
def get_mcp_servers(
|
|
185
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
186
|
+
) -> _types.McpServers:
|
|
187
|
+
"""GET /v1/mcp/servers — json response."""
|
|
188
|
+
response = self._client._request(
|
|
189
|
+
"GET", "/v1/mcp/servers", path={}, query=query, timeout=timeout
|
|
190
|
+
)
|
|
191
|
+
return response.json()
|
|
192
|
+
|
|
193
|
+
def post_mcp_servers(
|
|
194
|
+
self,
|
|
195
|
+
*,
|
|
196
|
+
query: Query | None = None,
|
|
197
|
+
timeout: float | None = None,
|
|
198
|
+
body: JSONValue = None,
|
|
199
|
+
) -> _types.McpServer:
|
|
200
|
+
"""POST /v1/mcp/servers — json response."""
|
|
201
|
+
response = self._client._request(
|
|
202
|
+
"POST", "/v1/mcp/servers", path={}, query=query, timeout=timeout, body=body
|
|
203
|
+
)
|
|
204
|
+
return response.json()
|
|
205
|
+
|
|
206
|
+
def delete_mcp_server(
|
|
207
|
+
self, name: str, *, query: Query | None = None, timeout: float | None = None
|
|
208
|
+
) -> _types.McpDeleted:
|
|
209
|
+
"""DELETE /v1/mcp/servers/:name — json response."""
|
|
210
|
+
response = self._client._request(
|
|
211
|
+
"DELETE",
|
|
212
|
+
"/v1/mcp/servers/:name",
|
|
213
|
+
path={"name": name},
|
|
214
|
+
query=query,
|
|
215
|
+
timeout=timeout,
|
|
216
|
+
)
|
|
217
|
+
return response.json()
|
|
218
|
+
|
|
219
|
+
def put_mcp_server(
|
|
220
|
+
self,
|
|
221
|
+
name: str,
|
|
222
|
+
*,
|
|
223
|
+
query: Query | None = None,
|
|
224
|
+
timeout: float | None = None,
|
|
225
|
+
body: JSONValue = None,
|
|
226
|
+
) -> _types.McpServer:
|
|
227
|
+
"""PUT /v1/mcp/servers/:name — json response."""
|
|
228
|
+
response = self._client._request(
|
|
229
|
+
"PUT",
|
|
230
|
+
"/v1/mcp/servers/:name",
|
|
231
|
+
path={"name": name},
|
|
232
|
+
query=query,
|
|
233
|
+
timeout=timeout,
|
|
234
|
+
body=body,
|
|
235
|
+
)
|
|
236
|
+
return response.json()
|
|
237
|
+
|
|
238
|
+
def post_mcp_server_enable(
|
|
239
|
+
self,
|
|
240
|
+
name: str,
|
|
241
|
+
*,
|
|
242
|
+
query: Query | None = None,
|
|
243
|
+
timeout: float | None = None,
|
|
244
|
+
body: JSONValue = None,
|
|
245
|
+
) -> _types.McpServer:
|
|
246
|
+
"""POST /v1/mcp/servers/:name/actions/enable — json response."""
|
|
247
|
+
response = self._client._request(
|
|
248
|
+
"POST",
|
|
249
|
+
"/v1/mcp/servers/:name/actions/enable",
|
|
250
|
+
path={"name": name},
|
|
251
|
+
query=query,
|
|
252
|
+
timeout=timeout,
|
|
253
|
+
body=body,
|
|
254
|
+
)
|
|
255
|
+
return response.json()
|
|
256
|
+
|
|
257
|
+
def post_mcp_server_kill(
|
|
258
|
+
self, name: str, *, query: Query | None = None, timeout: float | None = None
|
|
259
|
+
) -> _types.McpServer:
|
|
260
|
+
"""POST /v1/mcp/servers/:name/actions/kill — json response."""
|
|
261
|
+
response = self._client._request(
|
|
262
|
+
"POST",
|
|
263
|
+
"/v1/mcp/servers/:name/actions/kill",
|
|
264
|
+
path={"name": name},
|
|
265
|
+
query=query,
|
|
266
|
+
timeout=timeout,
|
|
267
|
+
)
|
|
268
|
+
return response.json()
|
|
269
|
+
|
|
270
|
+
def post_mcp_server_start(
|
|
271
|
+
self, name: str, *, query: Query | None = None, timeout: float | None = None
|
|
272
|
+
) -> _types.McpServer:
|
|
273
|
+
"""POST /v1/mcp/servers/:name/actions/start — json response."""
|
|
274
|
+
response = self._client._request(
|
|
275
|
+
"POST",
|
|
276
|
+
"/v1/mcp/servers/:name/actions/start",
|
|
277
|
+
path={"name": name},
|
|
278
|
+
query=query,
|
|
279
|
+
timeout=timeout,
|
|
280
|
+
)
|
|
281
|
+
return response.json()
|
|
282
|
+
|
|
283
|
+
def post_mcp_server_auth_cancel(
|
|
284
|
+
self,
|
|
285
|
+
name: str,
|
|
286
|
+
*,
|
|
287
|
+
query: Query | None = None,
|
|
288
|
+
timeout: float | None = None,
|
|
289
|
+
body: JSONValue = None,
|
|
290
|
+
) -> _types.McpAuthCancelled:
|
|
291
|
+
"""POST /v1/mcp/servers/:name/auth/cancel — json response."""
|
|
292
|
+
response = self._client._request(
|
|
293
|
+
"POST",
|
|
294
|
+
"/v1/mcp/servers/:name/auth/cancel",
|
|
295
|
+
path={"name": name},
|
|
296
|
+
query=query,
|
|
297
|
+
timeout=timeout,
|
|
298
|
+
body=body,
|
|
299
|
+
)
|
|
300
|
+
return response.json()
|
|
301
|
+
|
|
302
|
+
def post_mcp_server_auth_complete(
|
|
303
|
+
self,
|
|
304
|
+
name: str,
|
|
305
|
+
*,
|
|
306
|
+
query: Query | None = None,
|
|
307
|
+
timeout: float | None = None,
|
|
308
|
+
body: JSONValue = None,
|
|
309
|
+
) -> _types.McpAuthFlow:
|
|
310
|
+
"""POST /v1/mcp/servers/:name/auth/complete — json response."""
|
|
311
|
+
response = self._client._request(
|
|
312
|
+
"POST",
|
|
313
|
+
"/v1/mcp/servers/:name/auth/complete",
|
|
314
|
+
path={"name": name},
|
|
315
|
+
query=query,
|
|
316
|
+
timeout=timeout,
|
|
317
|
+
body=body,
|
|
318
|
+
)
|
|
319
|
+
return response.json()
|
|
320
|
+
|
|
321
|
+
def post_mcp_server_auth_logout(
|
|
322
|
+
self, name: str, *, query: Query | None = None, timeout: float | None = None
|
|
323
|
+
) -> _types.McpTokenStatus:
|
|
324
|
+
"""POST /v1/mcp/servers/:name/auth/logout — json response."""
|
|
325
|
+
response = self._client._request(
|
|
326
|
+
"POST",
|
|
327
|
+
"/v1/mcp/servers/:name/auth/logout",
|
|
328
|
+
path={"name": name},
|
|
329
|
+
query=query,
|
|
330
|
+
timeout=timeout,
|
|
331
|
+
)
|
|
332
|
+
return response.json()
|
|
333
|
+
|
|
334
|
+
def post_mcp_server_auth_poll(
|
|
335
|
+
self,
|
|
336
|
+
name: str,
|
|
337
|
+
*,
|
|
338
|
+
query: Query | None = None,
|
|
339
|
+
timeout: float | None = None,
|
|
340
|
+
body: JSONValue = None,
|
|
341
|
+
) -> _types.McpAuthFlow:
|
|
342
|
+
"""POST /v1/mcp/servers/:name/auth/poll — json response."""
|
|
343
|
+
response = self._client._request(
|
|
344
|
+
"POST",
|
|
345
|
+
"/v1/mcp/servers/:name/auth/poll",
|
|
346
|
+
path={"name": name},
|
|
347
|
+
query=query,
|
|
348
|
+
timeout=timeout,
|
|
349
|
+
body=body,
|
|
350
|
+
)
|
|
351
|
+
return response.json()
|
|
352
|
+
|
|
353
|
+
def post_mcp_server_auth_start(
|
|
354
|
+
self, name: str, *, query: Query | None = None, timeout: float | None = None
|
|
355
|
+
) -> _types.McpAuthFlow:
|
|
356
|
+
"""POST /v1/mcp/servers/:name/auth/start — json response."""
|
|
357
|
+
response = self._client._request(
|
|
358
|
+
"POST",
|
|
359
|
+
"/v1/mcp/servers/:name/auth/start",
|
|
360
|
+
path={"name": name},
|
|
361
|
+
query=query,
|
|
362
|
+
timeout=timeout,
|
|
363
|
+
)
|
|
364
|
+
return response.json()
|
|
365
|
+
|
|
366
|
+
def post_mcp_servers_test(
|
|
367
|
+
self,
|
|
368
|
+
*,
|
|
369
|
+
query: Query | None = None,
|
|
370
|
+
timeout: float | None = None,
|
|
371
|
+
body: JSONValue = None,
|
|
372
|
+
) -> _types.McpTest:
|
|
373
|
+
"""POST /v1/mcp/servers/actions/test — json response."""
|
|
374
|
+
response = self._client._request(
|
|
375
|
+
"POST",
|
|
376
|
+
"/v1/mcp/servers/actions/test",
|
|
377
|
+
path={},
|
|
378
|
+
query=query,
|
|
379
|
+
timeout=timeout,
|
|
380
|
+
body=body,
|
|
381
|
+
)
|
|
382
|
+
return response.json()
|
|
383
|
+
|
|
384
|
+
def get_models(
|
|
385
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
386
|
+
) -> _types.ModelsCatalog:
|
|
387
|
+
"""GET /v1/models — json response."""
|
|
388
|
+
response = self._client._request(
|
|
389
|
+
"GET", "/v1/models", path={}, query=query, timeout=timeout
|
|
390
|
+
)
|
|
391
|
+
return response.json()
|
|
392
|
+
|
|
393
|
+
def get_projects(
|
|
394
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
395
|
+
) -> _types.ProjectList:
|
|
396
|
+
"""GET /v1/projects — json response."""
|
|
397
|
+
response = self._client._request(
|
|
398
|
+
"GET", "/v1/projects", path={}, query=query, timeout=timeout
|
|
399
|
+
)
|
|
400
|
+
return response.json()
|
|
401
|
+
|
|
402
|
+
def post_projects(
|
|
403
|
+
self,
|
|
404
|
+
*,
|
|
405
|
+
query: Query | None = None,
|
|
406
|
+
timeout: float | None = None,
|
|
407
|
+
body: JSONValue = None,
|
|
408
|
+
) -> _types.Project:
|
|
409
|
+
"""POST /v1/projects — json response."""
|
|
410
|
+
response = self._client._request(
|
|
411
|
+
"POST", "/v1/projects", path={}, query=query, timeout=timeout, body=body
|
|
412
|
+
)
|
|
413
|
+
return response.json()
|
|
414
|
+
|
|
415
|
+
def delete_project(
|
|
416
|
+
self, pid: str, *, query: Query | None = None, timeout: float | None = None
|
|
417
|
+
) -> None:
|
|
418
|
+
"""DELETE /v1/projects/:pid — empty response."""
|
|
419
|
+
self._client._request(
|
|
420
|
+
"DELETE",
|
|
421
|
+
"/v1/projects/:pid",
|
|
422
|
+
path={"pid": pid},
|
|
423
|
+
query=query,
|
|
424
|
+
timeout=timeout,
|
|
425
|
+
)
|
|
426
|
+
return None
|
|
427
|
+
|
|
428
|
+
def get_project(
|
|
429
|
+
self, pid: str, *, query: Query | None = None, timeout: float | None = None
|
|
430
|
+
) -> _types.Project:
|
|
431
|
+
"""GET /v1/projects/:pid — json response."""
|
|
432
|
+
response = self._client._request(
|
|
433
|
+
"GET", "/v1/projects/:pid", path={"pid": pid}, query=query, timeout=timeout
|
|
434
|
+
)
|
|
435
|
+
return response.json()
|
|
436
|
+
|
|
437
|
+
def patch_project(
|
|
438
|
+
self,
|
|
439
|
+
pid: str,
|
|
440
|
+
*,
|
|
441
|
+
query: Query | None = None,
|
|
442
|
+
timeout: float | None = None,
|
|
443
|
+
body: JSONValue = None,
|
|
444
|
+
) -> _types.Project:
|
|
445
|
+
"""PATCH /v1/projects/:pid — json response."""
|
|
446
|
+
response = self._client._request(
|
|
447
|
+
"PATCH",
|
|
448
|
+
"/v1/projects/:pid",
|
|
449
|
+
path={"pid": pid},
|
|
450
|
+
query=query,
|
|
451
|
+
timeout=timeout,
|
|
452
|
+
body=body,
|
|
453
|
+
)
|
|
454
|
+
return response.json()
|
|
455
|
+
|
|
456
|
+
def patch_project_sessions(
|
|
457
|
+
self,
|
|
458
|
+
pid: str,
|
|
459
|
+
*,
|
|
460
|
+
query: Query | None = None,
|
|
461
|
+
timeout: float | None = None,
|
|
462
|
+
body: JSONValue = None,
|
|
463
|
+
) -> _types.ProjectSessionsMoved:
|
|
464
|
+
"""PATCH /v1/projects/:pid/sessions — json response."""
|
|
465
|
+
response = self._client._request(
|
|
466
|
+
"PATCH",
|
|
467
|
+
"/v1/projects/:pid/sessions",
|
|
468
|
+
path={"pid": pid},
|
|
469
|
+
query=query,
|
|
470
|
+
timeout=timeout,
|
|
471
|
+
body=body,
|
|
472
|
+
)
|
|
473
|
+
return response.json()
|
|
474
|
+
|
|
475
|
+
def post_projects_ensure(
|
|
476
|
+
self,
|
|
477
|
+
*,
|
|
478
|
+
query: Query | None = None,
|
|
479
|
+
timeout: float | None = None,
|
|
480
|
+
body: JSONValue = None,
|
|
481
|
+
) -> _types.Project:
|
|
482
|
+
"""POST /v1/projects/actions/ensure — json response."""
|
|
483
|
+
response = self._client._request(
|
|
484
|
+
"POST",
|
|
485
|
+
"/v1/projects/actions/ensure",
|
|
486
|
+
path={},
|
|
487
|
+
query=query,
|
|
488
|
+
timeout=timeout,
|
|
489
|
+
body=body,
|
|
490
|
+
)
|
|
491
|
+
return response.json()
|
|
492
|
+
|
|
493
|
+
def get_projects_overview(
|
|
494
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
495
|
+
) -> _types.ProjectOverview:
|
|
496
|
+
"""GET /v1/projects/overview — json response."""
|
|
497
|
+
response = self._client._request(
|
|
498
|
+
"GET", "/v1/projects/overview", path={}, query=query, timeout=timeout
|
|
499
|
+
)
|
|
500
|
+
return response.json()
|
|
501
|
+
|
|
502
|
+
def get_provider_presets(
|
|
503
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
504
|
+
) -> _types.ProviderPresets:
|
|
505
|
+
"""GET /v1/provider-presets — json response."""
|
|
506
|
+
response = self._client._request(
|
|
507
|
+
"GET", "/v1/provider-presets", path={}, query=query, timeout=timeout
|
|
508
|
+
)
|
|
509
|
+
return response.json()
|
|
510
|
+
|
|
511
|
+
def post_providers(
|
|
512
|
+
self,
|
|
513
|
+
*,
|
|
514
|
+
query: Query | None = None,
|
|
515
|
+
timeout: float | None = None,
|
|
516
|
+
body: JSONValue = None,
|
|
517
|
+
) -> _types.RouterFleet:
|
|
518
|
+
"""POST /v1/providers — json response."""
|
|
519
|
+
response = self._client._request(
|
|
520
|
+
"POST", "/v1/providers", path={}, query=query, timeout=timeout, body=body
|
|
521
|
+
)
|
|
522
|
+
return response.json()
|
|
523
|
+
|
|
524
|
+
def delete_provider(
|
|
525
|
+
self,
|
|
526
|
+
provider_id: str,
|
|
527
|
+
*,
|
|
528
|
+
query: Query | None = None,
|
|
529
|
+
timeout: float | None = None,
|
|
530
|
+
) -> _types.RouterFleet:
|
|
531
|
+
"""DELETE /v1/providers/:provider-id — json response."""
|
|
532
|
+
response = self._client._request(
|
|
533
|
+
"DELETE",
|
|
534
|
+
"/v1/providers/:provider-id",
|
|
535
|
+
path={"provider-id": provider_id},
|
|
536
|
+
query=query,
|
|
537
|
+
timeout=timeout,
|
|
538
|
+
)
|
|
539
|
+
return response.json()
|
|
540
|
+
|
|
541
|
+
def post_provider_auth_cancel(
|
|
542
|
+
self,
|
|
543
|
+
provider_id: str,
|
|
544
|
+
*,
|
|
545
|
+
query: Query | None = None,
|
|
546
|
+
timeout: float | None = None,
|
|
547
|
+
body: JSONValue = None,
|
|
548
|
+
) -> _types.ProviderAuth:
|
|
549
|
+
"""POST /v1/providers/:provider-id/auth/cancel — json response."""
|
|
550
|
+
response = self._client._request(
|
|
551
|
+
"POST",
|
|
552
|
+
"/v1/providers/:provider-id/auth/cancel",
|
|
553
|
+
path={"provider-id": provider_id},
|
|
554
|
+
query=query,
|
|
555
|
+
timeout=timeout,
|
|
556
|
+
body=body,
|
|
557
|
+
)
|
|
558
|
+
return response.json()
|
|
559
|
+
|
|
560
|
+
def post_provider_auth_complete(
|
|
561
|
+
self,
|
|
562
|
+
provider_id: str,
|
|
563
|
+
*,
|
|
564
|
+
query: Query | None = None,
|
|
565
|
+
timeout: float | None = None,
|
|
566
|
+
body: JSONValue = None,
|
|
567
|
+
) -> _types.ProviderAuth:
|
|
568
|
+
"""POST /v1/providers/:provider-id/auth/complete — json response."""
|
|
569
|
+
response = self._client._request(
|
|
570
|
+
"POST",
|
|
571
|
+
"/v1/providers/:provider-id/auth/complete",
|
|
572
|
+
path={"provider-id": provider_id},
|
|
573
|
+
query=query,
|
|
574
|
+
timeout=timeout,
|
|
575
|
+
body=body,
|
|
576
|
+
)
|
|
577
|
+
return response.json()
|
|
578
|
+
|
|
579
|
+
def post_provider_auth_poll(
|
|
580
|
+
self,
|
|
581
|
+
provider_id: str,
|
|
582
|
+
*,
|
|
583
|
+
query: Query | None = None,
|
|
584
|
+
timeout: float | None = None,
|
|
585
|
+
body: JSONValue = None,
|
|
586
|
+
) -> _types.ProviderAuth:
|
|
587
|
+
"""POST /v1/providers/:provider-id/auth/poll — json response."""
|
|
588
|
+
response = self._client._request(
|
|
589
|
+
"POST",
|
|
590
|
+
"/v1/providers/:provider-id/auth/poll",
|
|
591
|
+
path={"provider-id": provider_id},
|
|
592
|
+
query=query,
|
|
593
|
+
timeout=timeout,
|
|
594
|
+
body=body,
|
|
595
|
+
)
|
|
596
|
+
return response.json()
|
|
597
|
+
|
|
598
|
+
def post_provider_auth_start(
|
|
599
|
+
self,
|
|
600
|
+
provider_id: str,
|
|
601
|
+
*,
|
|
602
|
+
query: Query | None = None,
|
|
603
|
+
timeout: float | None = None,
|
|
604
|
+
) -> _types.ProviderAuth:
|
|
605
|
+
"""POST /v1/providers/:provider-id/auth/start — json response."""
|
|
606
|
+
response = self._client._request(
|
|
607
|
+
"POST",
|
|
608
|
+
"/v1/providers/:provider-id/auth/start",
|
|
609
|
+
path={"provider-id": provider_id},
|
|
610
|
+
query=query,
|
|
611
|
+
timeout=timeout,
|
|
612
|
+
)
|
|
613
|
+
return response.json()
|
|
614
|
+
|
|
615
|
+
def get_provider_limits(
|
|
616
|
+
self,
|
|
617
|
+
provider_id: str,
|
|
618
|
+
*,
|
|
619
|
+
query: Query | None = None,
|
|
620
|
+
timeout: float | None = None,
|
|
621
|
+
) -> _types.ProviderLimits:
|
|
622
|
+
"""GET /v1/providers/:provider-id/limits — json response."""
|
|
623
|
+
response = self._client._request(
|
|
624
|
+
"GET",
|
|
625
|
+
"/v1/providers/:provider-id/limits",
|
|
626
|
+
path={"provider-id": provider_id},
|
|
627
|
+
query=query,
|
|
628
|
+
timeout=timeout,
|
|
629
|
+
)
|
|
630
|
+
return response.json()
|
|
631
|
+
|
|
632
|
+
def post_provider_reset_credits_consume(
|
|
633
|
+
self,
|
|
634
|
+
provider_id: str,
|
|
635
|
+
*,
|
|
636
|
+
query: Query | None = None,
|
|
637
|
+
timeout: float | None = None,
|
|
638
|
+
body: JSONValue = None,
|
|
639
|
+
) -> _types.ProviderResetOutcome:
|
|
640
|
+
"""POST /v1/providers/:provider-id/reset-credits/consume — json response."""
|
|
641
|
+
response = self._client._request(
|
|
642
|
+
"POST",
|
|
643
|
+
"/v1/providers/:provider-id/reset-credits/consume",
|
|
644
|
+
path={"provider-id": provider_id},
|
|
645
|
+
query=query,
|
|
646
|
+
timeout=timeout,
|
|
647
|
+
body=body,
|
|
648
|
+
)
|
|
649
|
+
return response.json()
|
|
650
|
+
|
|
651
|
+
def post_provider_logout(
|
|
652
|
+
self,
|
|
653
|
+
provider_id: str,
|
|
654
|
+
*,
|
|
655
|
+
query: Query | None = None,
|
|
656
|
+
timeout: float | None = None,
|
|
657
|
+
) -> _types.ProviderAuth:
|
|
658
|
+
"""POST /v1/providers/:provider-id/logout — json response."""
|
|
659
|
+
response = self._client._request(
|
|
660
|
+
"POST",
|
|
661
|
+
"/v1/providers/:provider-id/logout",
|
|
662
|
+
path={"provider-id": provider_id},
|
|
663
|
+
query=query,
|
|
664
|
+
timeout=timeout,
|
|
665
|
+
)
|
|
666
|
+
return response.json()
|
|
667
|
+
|
|
668
|
+
def get_provider_models(
|
|
669
|
+
self,
|
|
670
|
+
provider_id: str,
|
|
671
|
+
*,
|
|
672
|
+
query: Query | None = None,
|
|
673
|
+
timeout: float | None = None,
|
|
674
|
+
) -> _types.ProviderModels:
|
|
675
|
+
"""GET /v1/providers/:provider-id/models — json response."""
|
|
676
|
+
response = self._client._request(
|
|
677
|
+
"GET",
|
|
678
|
+
"/v1/providers/:provider-id/models",
|
|
679
|
+
path={"provider-id": provider_id},
|
|
680
|
+
query=query,
|
|
681
|
+
timeout=timeout,
|
|
682
|
+
)
|
|
683
|
+
return response.json()
|
|
684
|
+
|
|
685
|
+
def get_provider_status(
|
|
686
|
+
self,
|
|
687
|
+
provider_id: str,
|
|
688
|
+
*,
|
|
689
|
+
query: Query | None = None,
|
|
690
|
+
timeout: float | None = None,
|
|
691
|
+
) -> _types.ProviderStatus:
|
|
692
|
+
"""GET /v1/providers/:provider-id/status — json response."""
|
|
693
|
+
response = self._client._request(
|
|
694
|
+
"GET",
|
|
695
|
+
"/v1/providers/:provider-id/status",
|
|
696
|
+
path={"provider-id": provider_id},
|
|
697
|
+
query=query,
|
|
698
|
+
timeout=timeout,
|
|
699
|
+
)
|
|
700
|
+
return response.json()
|
|
701
|
+
|
|
702
|
+
def get_router(
|
|
703
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
704
|
+
) -> _types.RouterFleet:
|
|
705
|
+
"""GET /v1/router — json response."""
|
|
706
|
+
response = self._client._request(
|
|
707
|
+
"GET", "/v1/router", path={}, query=query, timeout=timeout
|
|
708
|
+
)
|
|
709
|
+
return response.json()
|
|
710
|
+
|
|
711
|
+
def patch_router(
|
|
712
|
+
self,
|
|
713
|
+
*,
|
|
714
|
+
query: Query | None = None,
|
|
715
|
+
timeout: float | None = None,
|
|
716
|
+
body: JSONValue = None,
|
|
717
|
+
) -> _types.RouterFleet:
|
|
718
|
+
"""PATCH /v1/router — json response."""
|
|
719
|
+
response = self._client._request(
|
|
720
|
+
"PATCH", "/v1/router", path={}, query=query, timeout=timeout, body=body
|
|
721
|
+
)
|
|
722
|
+
return response.json()
|
|
723
|
+
|
|
724
|
+
def get_session_groups(
|
|
725
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
726
|
+
) -> _types.SessionGroupPage:
|
|
727
|
+
"""GET /v1/session-groups — the groups of one project, in the human's order."""
|
|
728
|
+
response = self._client._request(
|
|
729
|
+
"GET", "/v1/session-groups", path={}, query=query, timeout=timeout
|
|
730
|
+
)
|
|
731
|
+
return response.json()
|
|
732
|
+
|
|
733
|
+
def post_session_groups(
|
|
734
|
+
self,
|
|
735
|
+
*,
|
|
736
|
+
query: Query | None = None,
|
|
737
|
+
timeout: float | None = None,
|
|
738
|
+
body: JSONValue = None,
|
|
739
|
+
) -> _types.SessionGroupRecord:
|
|
740
|
+
"""POST /v1/session-groups — create one group inside a project."""
|
|
741
|
+
response = self._client._request(
|
|
742
|
+
"POST",
|
|
743
|
+
"/v1/session-groups",
|
|
744
|
+
path={},
|
|
745
|
+
query=query,
|
|
746
|
+
timeout=timeout,
|
|
747
|
+
body=body,
|
|
748
|
+
)
|
|
749
|
+
return response.json()
|
|
750
|
+
|
|
751
|
+
def delete_session_group(
|
|
752
|
+
self, gid: str, *, query: Query | None = None, timeout: float | None = None
|
|
753
|
+
) -> _types.SessionGroupDeleted:
|
|
754
|
+
"""DELETE /v1/session-groups/:gid — drop a group and say what becomes of it."""
|
|
755
|
+
response = self._client._request(
|
|
756
|
+
"DELETE",
|
|
757
|
+
"/v1/session-groups/:gid",
|
|
758
|
+
path={"gid": gid},
|
|
759
|
+
query=query,
|
|
760
|
+
timeout=timeout,
|
|
761
|
+
)
|
|
762
|
+
return response.json()
|
|
763
|
+
|
|
764
|
+
def patch_session_group(
|
|
765
|
+
self,
|
|
766
|
+
gid: str,
|
|
767
|
+
*,
|
|
768
|
+
query: Query | None = None,
|
|
769
|
+
timeout: float | None = None,
|
|
770
|
+
body: JSONValue = None,
|
|
771
|
+
) -> _types.SessionGroupRecord:
|
|
772
|
+
"""PATCH /v1/session-groups/:gid — rename, recolour or reorder a group."""
|
|
773
|
+
response = self._client._request(
|
|
774
|
+
"PATCH",
|
|
775
|
+
"/v1/session-groups/:gid",
|
|
776
|
+
path={"gid": gid},
|
|
777
|
+
query=query,
|
|
778
|
+
timeout=timeout,
|
|
779
|
+
body=body,
|
|
780
|
+
)
|
|
781
|
+
return response.json()
|
|
782
|
+
|
|
783
|
+
def get_sessions(
|
|
784
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
785
|
+
) -> _types.SessionList:
|
|
786
|
+
"""GET /v1/sessions — json response."""
|
|
787
|
+
response = self._client._request(
|
|
788
|
+
"GET", "/v1/sessions", path={}, query=query, timeout=timeout
|
|
789
|
+
)
|
|
790
|
+
return response.json()
|
|
791
|
+
|
|
792
|
+
def post_sessions(
|
|
793
|
+
self,
|
|
794
|
+
*,
|
|
795
|
+
query: Query | None = None,
|
|
796
|
+
timeout: float | None = None,
|
|
797
|
+
body: JSONValue = None,
|
|
798
|
+
) -> _types.SessionRecord:
|
|
799
|
+
"""POST /v1/sessions — json response."""
|
|
800
|
+
response = self._client._request(
|
|
801
|
+
"POST", "/v1/sessions", path={}, query=query, timeout=timeout, body=body
|
|
802
|
+
)
|
|
803
|
+
return response.json()
|
|
804
|
+
|
|
805
|
+
def delete_session(
|
|
806
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
807
|
+
) -> None:
|
|
808
|
+
"""DELETE /v1/sessions/:sid — empty response."""
|
|
809
|
+
self._client._request(
|
|
810
|
+
"DELETE",
|
|
811
|
+
"/v1/sessions/:sid",
|
|
812
|
+
path={"sid": sid},
|
|
813
|
+
query=query,
|
|
814
|
+
timeout=timeout,
|
|
815
|
+
)
|
|
816
|
+
return None
|
|
817
|
+
|
|
818
|
+
def get_session(
|
|
819
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
820
|
+
) -> _types.SessionRecord:
|
|
821
|
+
"""GET /v1/sessions/:sid — json response."""
|
|
822
|
+
response = self._client._request(
|
|
823
|
+
"GET", "/v1/sessions/:sid", path={"sid": sid}, query=query, timeout=timeout
|
|
824
|
+
)
|
|
825
|
+
return response.json()
|
|
826
|
+
|
|
827
|
+
def patch_session(
|
|
828
|
+
self,
|
|
829
|
+
sid: str,
|
|
830
|
+
*,
|
|
831
|
+
query: Query | None = None,
|
|
832
|
+
timeout: float | None = None,
|
|
833
|
+
body: JSONValue = None,
|
|
834
|
+
) -> _types.SessionRecord:
|
|
835
|
+
"""PATCH /v1/sessions/:sid — json response."""
|
|
836
|
+
response = self._client._request(
|
|
837
|
+
"PATCH",
|
|
838
|
+
"/v1/sessions/:sid",
|
|
839
|
+
path={"sid": sid},
|
|
840
|
+
query=query,
|
|
841
|
+
timeout=timeout,
|
|
842
|
+
body=body,
|
|
843
|
+
)
|
|
844
|
+
return response.json()
|
|
845
|
+
|
|
846
|
+
def get_session_activity(
|
|
847
|
+
self,
|
|
848
|
+
sid: str,
|
|
849
|
+
aid: str,
|
|
850
|
+
*,
|
|
851
|
+
query: Query | None = None,
|
|
852
|
+
timeout: float | None = None,
|
|
853
|
+
) -> _types.ActivityPage:
|
|
854
|
+
"""GET /v1/sessions/:sid/activity/:aid — a bounded page of complete Activity records.
|
|
855
|
+
|
|
856
|
+
Query with after, limit and q. Follow history.next_after until it is
|
|
857
|
+
null. When you combine pages into one copy, reject a changed revision.
|
|
858
|
+
"""
|
|
859
|
+
response = self._client._request(
|
|
860
|
+
"GET",
|
|
861
|
+
"/v1/sessions/:sid/activity/:aid",
|
|
862
|
+
path={"sid": sid, "aid": aid},
|
|
863
|
+
query=query,
|
|
864
|
+
timeout=timeout,
|
|
865
|
+
)
|
|
866
|
+
return response.json()
|
|
867
|
+
|
|
868
|
+
def get_session_activity_export(
|
|
869
|
+
self,
|
|
870
|
+
sid: str,
|
|
871
|
+
aid: str,
|
|
872
|
+
*,
|
|
873
|
+
query: Query | None = None,
|
|
874
|
+
timeout: float | None = None,
|
|
875
|
+
) -> Response:
|
|
876
|
+
"""GET /v1/sessions/:sid/activity/:aid/export — complete unfiltered Activity text.
|
|
877
|
+
|
|
878
|
+
The gateway streams this response, and the returned Response buffers its
|
|
879
|
+
bytes. Supply revision to reject a changed history before the export
|
|
880
|
+
starts. Raises ProtocolError if a concurrent change marks the export
|
|
881
|
+
incomplete.
|
|
882
|
+
"""
|
|
883
|
+
response = self._client._request(
|
|
884
|
+
"GET",
|
|
885
|
+
"/v1/sessions/:sid/activity/:aid/export",
|
|
886
|
+
path={"sid": sid, "aid": aid},
|
|
887
|
+
query=query,
|
|
888
|
+
timeout=timeout,
|
|
889
|
+
)
|
|
890
|
+
if response.content.endswith(
|
|
891
|
+
b"\n\nINCOMPLETE EXPORT: Activity changed. Reload and retry.\n"
|
|
892
|
+
):
|
|
893
|
+
from ._client import ProtocolError
|
|
894
|
+
|
|
895
|
+
raise ProtocolError("Activity export is incomplete; reload and retry")
|
|
896
|
+
return response
|
|
897
|
+
|
|
898
|
+
def get_session_alert(
|
|
899
|
+
self, sid: str, *, timeout: float | None = None
|
|
900
|
+
) -> _types.SessionAlert:
|
|
901
|
+
"""GET /v1/sessions/:sid/alert — the banner text for the latest turn."""
|
|
902
|
+
return self._client._request(
|
|
903
|
+
"GET",
|
|
904
|
+
"/v1/sessions/:sid/alert",
|
|
905
|
+
path={"sid": sid},
|
|
906
|
+
timeout=timeout,
|
|
907
|
+
).json()
|
|
908
|
+
|
|
909
|
+
def get_session_artifacts(
|
|
910
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
911
|
+
) -> _types.SessionArtifacts:
|
|
912
|
+
"""GET /v1/sessions/:sid/artifacts — json response."""
|
|
913
|
+
response = self._client._request(
|
|
914
|
+
"GET",
|
|
915
|
+
"/v1/sessions/:sid/artifacts",
|
|
916
|
+
path={"sid": sid},
|
|
917
|
+
query=query,
|
|
918
|
+
timeout=timeout,
|
|
919
|
+
)
|
|
920
|
+
return response.json()
|
|
921
|
+
|
|
922
|
+
def post_session_attachments(
|
|
923
|
+
self,
|
|
924
|
+
sid: str,
|
|
925
|
+
*,
|
|
926
|
+
query: Query | None = None,
|
|
927
|
+
timeout: float | None = None,
|
|
928
|
+
content: bytes | None,
|
|
929
|
+
) -> _types.Upload:
|
|
930
|
+
"""POST /v1/sessions/:sid/attachments — json response."""
|
|
931
|
+
response = self._client._request(
|
|
932
|
+
"POST",
|
|
933
|
+
"/v1/sessions/:sid/attachments",
|
|
934
|
+
path={"sid": sid},
|
|
935
|
+
query=query,
|
|
936
|
+
timeout=timeout,
|
|
937
|
+
content=content,
|
|
938
|
+
)
|
|
939
|
+
return response.json()
|
|
940
|
+
|
|
941
|
+
def post_session_cancel_current(
|
|
942
|
+
self,
|
|
943
|
+
sid: str,
|
|
944
|
+
*,
|
|
945
|
+
query: Query | None = None,
|
|
946
|
+
timeout: float | None = None,
|
|
947
|
+
body: JSONValue = None,
|
|
948
|
+
) -> _types.TurnCancel:
|
|
949
|
+
"""POST /v1/sessions/:sid/cancel-current — json response."""
|
|
950
|
+
response = self._client._request(
|
|
951
|
+
"POST",
|
|
952
|
+
"/v1/sessions/:sid/cancel-current",
|
|
953
|
+
path={"sid": sid},
|
|
954
|
+
query=query,
|
|
955
|
+
timeout=timeout,
|
|
956
|
+
body=body,
|
|
957
|
+
)
|
|
958
|
+
return response.json()
|
|
959
|
+
|
|
960
|
+
def get_session_context(
|
|
961
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
962
|
+
) -> _types.SessionContext:
|
|
963
|
+
"""GET /v1/sessions/:sid/context — json response."""
|
|
964
|
+
response = self._client._request(
|
|
965
|
+
"GET",
|
|
966
|
+
"/v1/sessions/:sid/context",
|
|
967
|
+
path={"sid": sid},
|
|
968
|
+
query=query,
|
|
969
|
+
timeout=timeout,
|
|
970
|
+
)
|
|
971
|
+
return response.json()
|
|
972
|
+
|
|
973
|
+
def post_session_drain_queue(
|
|
974
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
975
|
+
) -> _types.TurnQueueStep:
|
|
976
|
+
"""POST /v1/sessions/:sid/drain-queue — json response."""
|
|
977
|
+
response = self._client._request(
|
|
978
|
+
"POST",
|
|
979
|
+
"/v1/sessions/:sid/drain-queue",
|
|
980
|
+
path={"sid": sid},
|
|
981
|
+
query=query,
|
|
982
|
+
timeout=timeout,
|
|
983
|
+
)
|
|
984
|
+
return response.json()
|
|
985
|
+
|
|
986
|
+
def get_session_events_since(
|
|
987
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
988
|
+
) -> _types.SessionEvents:
|
|
989
|
+
"""GET /v1/sessions/:sid/events-since — json response."""
|
|
990
|
+
response = self._client._request(
|
|
991
|
+
"GET",
|
|
992
|
+
"/v1/sessions/:sid/events-since",
|
|
993
|
+
path={"sid": sid},
|
|
994
|
+
query=query,
|
|
995
|
+
timeout=timeout,
|
|
996
|
+
)
|
|
997
|
+
return response.json()
|
|
998
|
+
|
|
999
|
+
def get_session_forks(
|
|
1000
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1001
|
+
) -> _types.SessionForkTurns:
|
|
1002
|
+
"""GET /v1/sessions/:sid/forks — json response."""
|
|
1003
|
+
response = self._client._request(
|
|
1004
|
+
"GET",
|
|
1005
|
+
"/v1/sessions/:sid/forks",
|
|
1006
|
+
path={"sid": sid},
|
|
1007
|
+
query=query,
|
|
1008
|
+
timeout=timeout,
|
|
1009
|
+
)
|
|
1010
|
+
return response.json()
|
|
1011
|
+
|
|
1012
|
+
def post_session_forks(
|
|
1013
|
+
self,
|
|
1014
|
+
sid: str,
|
|
1015
|
+
*,
|
|
1016
|
+
query: Query | None = None,
|
|
1017
|
+
timeout: float | None = None,
|
|
1018
|
+
body: JSONValue = None,
|
|
1019
|
+
) -> _types.SessionWrapped:
|
|
1020
|
+
"""POST /v1/sessions/:sid/forks — json response."""
|
|
1021
|
+
response = self._client._request(
|
|
1022
|
+
"POST",
|
|
1023
|
+
"/v1/sessions/:sid/forks",
|
|
1024
|
+
path={"sid": sid},
|
|
1025
|
+
query=query,
|
|
1026
|
+
timeout=timeout,
|
|
1027
|
+
body=body,
|
|
1028
|
+
)
|
|
1029
|
+
return response.json()
|
|
1030
|
+
|
|
1031
|
+
def post_session_fs_actions_open(
|
|
1032
|
+
self,
|
|
1033
|
+
sid: str,
|
|
1034
|
+
*,
|
|
1035
|
+
query: Query | None = None,
|
|
1036
|
+
timeout: float | None = None,
|
|
1037
|
+
body: JSONValue = None,
|
|
1038
|
+
) -> _types.SessionFsOpen:
|
|
1039
|
+
"""POST /v1/sessions/:sid/fs/actions/open — open one file in the editor."""
|
|
1040
|
+
response = self._client._request(
|
|
1041
|
+
"POST",
|
|
1042
|
+
"/v1/sessions/:sid/fs/actions/open",
|
|
1043
|
+
path={"sid": sid},
|
|
1044
|
+
query=query,
|
|
1045
|
+
timeout=timeout,
|
|
1046
|
+
body=body,
|
|
1047
|
+
)
|
|
1048
|
+
return response.json()
|
|
1049
|
+
|
|
1050
|
+
def get_session_fs_file(
|
|
1051
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1052
|
+
) -> _types.FilePreview:
|
|
1053
|
+
"""GET /v1/sessions/:sid/fs/file — preview one workspace file by its kind."""
|
|
1054
|
+
response = self._client._request(
|
|
1055
|
+
"GET",
|
|
1056
|
+
"/v1/sessions/:sid/fs/file",
|
|
1057
|
+
path={"sid": sid},
|
|
1058
|
+
query=query,
|
|
1059
|
+
timeout=timeout,
|
|
1060
|
+
)
|
|
1061
|
+
return response.json()
|
|
1062
|
+
|
|
1063
|
+
def get_session_fs_file_content(
|
|
1064
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1065
|
+
) -> Response:
|
|
1066
|
+
"""GET /v1/sessions/:sid/fs/file/content — binary response.
|
|
1067
|
+
|
|
1068
|
+
Stream one recording or clip. Pass the path, expires and ticket of the
|
|
1069
|
+
content_url that the media preview of get_session_fs_file gives.
|
|
1070
|
+
"""
|
|
1071
|
+
response = self._client._request(
|
|
1072
|
+
"GET",
|
|
1073
|
+
"/v1/sessions/:sid/fs/file/content",
|
|
1074
|
+
path={"sid": sid},
|
|
1075
|
+
query=query,
|
|
1076
|
+
timeout=timeout,
|
|
1077
|
+
)
|
|
1078
|
+
return response
|
|
1079
|
+
|
|
1080
|
+
def put_session_group(
|
|
1081
|
+
self,
|
|
1082
|
+
sid: str,
|
|
1083
|
+
*,
|
|
1084
|
+
query: Query | None = None,
|
|
1085
|
+
timeout: float | None = None,
|
|
1086
|
+
body: JSONValue = None,
|
|
1087
|
+
) -> _types.SessionRecord:
|
|
1088
|
+
"""PUT /v1/sessions/:sid/group — file this session under a group."""
|
|
1089
|
+
response = self._client._request(
|
|
1090
|
+
"PUT",
|
|
1091
|
+
"/v1/sessions/:sid/group",
|
|
1092
|
+
path={"sid": sid},
|
|
1093
|
+
query=query,
|
|
1094
|
+
timeout=timeout,
|
|
1095
|
+
body=body,
|
|
1096
|
+
)
|
|
1097
|
+
return response.json()
|
|
1098
|
+
|
|
1099
|
+
def get_session_iteration_attachments(
|
|
1100
|
+
self,
|
|
1101
|
+
sid: str,
|
|
1102
|
+
iid: str,
|
|
1103
|
+
idx: str,
|
|
1104
|
+
*,
|
|
1105
|
+
query: Query | None = None,
|
|
1106
|
+
timeout: float | None = None,
|
|
1107
|
+
) -> Response:
|
|
1108
|
+
"""GET /v1/sessions/:sid/iterations/:iid/attachments/:idx — binary response."""
|
|
1109
|
+
response = self._client._request(
|
|
1110
|
+
"GET",
|
|
1111
|
+
"/v1/sessions/:sid/iterations/:iid/attachments/:idx",
|
|
1112
|
+
path={"sid": sid, "iid": iid, "idx": idx},
|
|
1113
|
+
query=query,
|
|
1114
|
+
timeout=timeout,
|
|
1115
|
+
)
|
|
1116
|
+
return response
|
|
1117
|
+
|
|
1118
|
+
def get_session_iteration_attachment_link(
|
|
1119
|
+
self,
|
|
1120
|
+
sid: str,
|
|
1121
|
+
iid: str,
|
|
1122
|
+
idx: str,
|
|
1123
|
+
*,
|
|
1124
|
+
query: Query | None = None,
|
|
1125
|
+
timeout: float | None = None,
|
|
1126
|
+
) -> _types.AttachmentLink:
|
|
1127
|
+
"""GET /v1/sessions/:sid/iterations/:iid/attachments/:idx/link — JSON response.
|
|
1128
|
+
|
|
1129
|
+
Get a signed content_url for an attachment that keeps a reference to a
|
|
1130
|
+
file on the gateway machine. A frame, a download link or another app
|
|
1131
|
+
opens that address without the gateway token.
|
|
1132
|
+
"""
|
|
1133
|
+
response = self._client._request(
|
|
1134
|
+
"GET",
|
|
1135
|
+
"/v1/sessions/:sid/iterations/:iid/attachments/:idx/link",
|
|
1136
|
+
path={"sid": sid, "iid": iid, "idx": idx},
|
|
1137
|
+
query=query,
|
|
1138
|
+
timeout=timeout,
|
|
1139
|
+
)
|
|
1140
|
+
return response.json()
|
|
1141
|
+
|
|
1142
|
+
def put_session_iteration_attachment_agent_note(
|
|
1143
|
+
self,
|
|
1144
|
+
sid: str,
|
|
1145
|
+
iid: str,
|
|
1146
|
+
idx: str,
|
|
1147
|
+
*,
|
|
1148
|
+
query: Query | None = None,
|
|
1149
|
+
timeout: float | None = None,
|
|
1150
|
+
body: JSONValue = None,
|
|
1151
|
+
) -> _types.AgentNote:
|
|
1152
|
+
"""PUT /v1/sessions/:sid/iterations/:iid/attachments/:idx/agent-note — set the note of an HTML page for the model."""
|
|
1153
|
+
response = self._client._request(
|
|
1154
|
+
"PUT",
|
|
1155
|
+
"/v1/sessions/:sid/iterations/:iid/attachments/:idx/agent-note",
|
|
1156
|
+
path={"sid": sid, "iid": iid, "idx": idx},
|
|
1157
|
+
query=query,
|
|
1158
|
+
timeout=timeout,
|
|
1159
|
+
body=body,
|
|
1160
|
+
)
|
|
1161
|
+
return response.json()
|
|
1162
|
+
|
|
1163
|
+
def get_session_model(
|
|
1164
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1165
|
+
) -> _types.SessionModelRecord:
|
|
1166
|
+
"""GET /v1/sessions/:sid/model — json response."""
|
|
1167
|
+
response = self._client._request(
|
|
1168
|
+
"GET",
|
|
1169
|
+
"/v1/sessions/:sid/model",
|
|
1170
|
+
path={"sid": sid},
|
|
1171
|
+
query=query,
|
|
1172
|
+
timeout=timeout,
|
|
1173
|
+
)
|
|
1174
|
+
return response.json()
|
|
1175
|
+
|
|
1176
|
+
def patch_session_model(
|
|
1177
|
+
self,
|
|
1178
|
+
sid: str,
|
|
1179
|
+
*,
|
|
1180
|
+
query: Query | None = None,
|
|
1181
|
+
timeout: float | None = None,
|
|
1182
|
+
body: JSONValue = None,
|
|
1183
|
+
) -> _types.SessionModelRecord:
|
|
1184
|
+
"""PATCH /v1/sessions/:sid/model — json response."""
|
|
1185
|
+
response = self._client._request(
|
|
1186
|
+
"PATCH",
|
|
1187
|
+
"/v1/sessions/:sid/model",
|
|
1188
|
+
path={"sid": sid},
|
|
1189
|
+
query=query,
|
|
1190
|
+
timeout=timeout,
|
|
1191
|
+
body=body,
|
|
1192
|
+
)
|
|
1193
|
+
return response.json()
|
|
1194
|
+
|
|
1195
|
+
def post_session_queue_send_now(
|
|
1196
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1197
|
+
) -> _types.QueueSendNow:
|
|
1198
|
+
"""POST /v1/sessions/:sid/queue/send-now — json response."""
|
|
1199
|
+
response = self._client._request(
|
|
1200
|
+
"POST",
|
|
1201
|
+
"/v1/sessions/:sid/queue/send-now",
|
|
1202
|
+
path={"sid": sid},
|
|
1203
|
+
query=query,
|
|
1204
|
+
timeout=timeout,
|
|
1205
|
+
)
|
|
1206
|
+
return response.json()
|
|
1207
|
+
|
|
1208
|
+
def put_session_read(
|
|
1209
|
+
self,
|
|
1210
|
+
sid: str,
|
|
1211
|
+
*,
|
|
1212
|
+
query: Query | None = None,
|
|
1213
|
+
timeout: float | None = None,
|
|
1214
|
+
body: JSONValue = None,
|
|
1215
|
+
) -> _types.SessionRead:
|
|
1216
|
+
"""PUT /v1/sessions/:sid/read — how far this reader has read the session."""
|
|
1217
|
+
response = self._client._request(
|
|
1218
|
+
"PUT",
|
|
1219
|
+
"/v1/sessions/:sid/read",
|
|
1220
|
+
path={"sid": sid},
|
|
1221
|
+
query=query,
|
|
1222
|
+
timeout=timeout,
|
|
1223
|
+
body=body,
|
|
1224
|
+
)
|
|
1225
|
+
return response.json()
|
|
1226
|
+
|
|
1227
|
+
def post_session_release(
|
|
1228
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1229
|
+
) -> None:
|
|
1230
|
+
"""POST /v1/sessions/:sid/release — empty response."""
|
|
1231
|
+
self._client._request(
|
|
1232
|
+
"POST",
|
|
1233
|
+
"/v1/sessions/:sid/release",
|
|
1234
|
+
path={"sid": sid},
|
|
1235
|
+
query=query,
|
|
1236
|
+
timeout=timeout,
|
|
1237
|
+
)
|
|
1238
|
+
return None
|
|
1239
|
+
|
|
1240
|
+
def get_session_resources(
|
|
1241
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1242
|
+
) -> _types.SessionResources:
|
|
1243
|
+
"""GET /v1/sessions/:sid/resources — json response."""
|
|
1244
|
+
response = self._client._request(
|
|
1245
|
+
"GET",
|
|
1246
|
+
"/v1/sessions/:sid/resources",
|
|
1247
|
+
path={"sid": sid},
|
|
1248
|
+
query=query,
|
|
1249
|
+
timeout=timeout,
|
|
1250
|
+
)
|
|
1251
|
+
return response.json()
|
|
1252
|
+
|
|
1253
|
+
def get_session_resources_logs(
|
|
1254
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1255
|
+
) -> _types.SessionResourceLogs:
|
|
1256
|
+
"""GET /v1/sessions/:sid/resources/logs — json response."""
|
|
1257
|
+
response = self._client._request(
|
|
1258
|
+
"GET",
|
|
1259
|
+
"/v1/sessions/:sid/resources/logs",
|
|
1260
|
+
path={"sid": sid},
|
|
1261
|
+
query=query,
|
|
1262
|
+
timeout=timeout,
|
|
1263
|
+
)
|
|
1264
|
+
return response.json()
|
|
1265
|
+
|
|
1266
|
+
def post_session_resources_stop(
|
|
1267
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1268
|
+
) -> _types.SessionResourceStop:
|
|
1269
|
+
"""POST /v1/sessions/:sid/resources/stop — json response."""
|
|
1270
|
+
response = self._client._request(
|
|
1271
|
+
"POST",
|
|
1272
|
+
"/v1/sessions/:sid/resources/stop",
|
|
1273
|
+
path={"sid": sid},
|
|
1274
|
+
query=query,
|
|
1275
|
+
timeout=timeout,
|
|
1276
|
+
)
|
|
1277
|
+
return response.json()
|
|
1278
|
+
|
|
1279
|
+
def post_session_resume_queue(
|
|
1280
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1281
|
+
) -> _types.TurnQueueStep:
|
|
1282
|
+
"""POST /v1/sessions/:sid/resume-queue — json response."""
|
|
1283
|
+
response = self._client._request(
|
|
1284
|
+
"POST",
|
|
1285
|
+
"/v1/sessions/:sid/resume-queue",
|
|
1286
|
+
path={"sid": sid},
|
|
1287
|
+
query=query,
|
|
1288
|
+
timeout=timeout,
|
|
1289
|
+
)
|
|
1290
|
+
return response.json()
|
|
1291
|
+
|
|
1292
|
+
def get_session_seq(
|
|
1293
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1294
|
+
) -> _types.SessionSeq:
|
|
1295
|
+
"""GET /v1/sessions/:sid/seq — json response."""
|
|
1296
|
+
response = self._client._request(
|
|
1297
|
+
"GET",
|
|
1298
|
+
"/v1/sessions/:sid/seq",
|
|
1299
|
+
path={"sid": sid},
|
|
1300
|
+
query=query,
|
|
1301
|
+
timeout=timeout,
|
|
1302
|
+
)
|
|
1303
|
+
return response.json()
|
|
1304
|
+
|
|
1305
|
+
def get_session_slashes(
|
|
1306
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1307
|
+
) -> _types.SessionSlashes:
|
|
1308
|
+
"""GET /v1/sessions/:sid/slashes — json response."""
|
|
1309
|
+
response = self._client._request(
|
|
1310
|
+
"GET",
|
|
1311
|
+
"/v1/sessions/:sid/slashes",
|
|
1312
|
+
path={"sid": sid},
|
|
1313
|
+
query=query,
|
|
1314
|
+
timeout=timeout,
|
|
1315
|
+
)
|
|
1316
|
+
return response.json()
|
|
1317
|
+
|
|
1318
|
+
def get_session_keybindings(
|
|
1319
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1320
|
+
) -> _types.KeybindingList:
|
|
1321
|
+
"""GET /v1/sessions/:sid/keybindings — json response."""
|
|
1322
|
+
response = self._client._request(
|
|
1323
|
+
"GET",
|
|
1324
|
+
"/v1/sessions/:sid/keybindings",
|
|
1325
|
+
path={"sid": sid},
|
|
1326
|
+
query=query,
|
|
1327
|
+
timeout=timeout,
|
|
1328
|
+
)
|
|
1329
|
+
return response.json()
|
|
1330
|
+
|
|
1331
|
+
def post_session_keybindings_run(
|
|
1332
|
+
self,
|
|
1333
|
+
sid: str,
|
|
1334
|
+
*,
|
|
1335
|
+
query: Query | None = None,
|
|
1336
|
+
timeout: float | None = None,
|
|
1337
|
+
body: JSONValue = None,
|
|
1338
|
+
) -> _types.KeybindingRunResult:
|
|
1339
|
+
"""POST /v1/sessions/:sid/keybindings/run — json response."""
|
|
1340
|
+
response = self._client._request(
|
|
1341
|
+
"POST",
|
|
1342
|
+
"/v1/sessions/:sid/keybindings/run",
|
|
1343
|
+
path={"sid": sid},
|
|
1344
|
+
query=query,
|
|
1345
|
+
timeout=timeout,
|
|
1346
|
+
body=body,
|
|
1347
|
+
)
|
|
1348
|
+
return response.json()
|
|
1349
|
+
|
|
1350
|
+
def get_session_snapshot(
|
|
1351
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1352
|
+
) -> Response:
|
|
1353
|
+
"""GET /v1/sessions/:sid/snapshot — binary response."""
|
|
1354
|
+
response = self._client._request(
|
|
1355
|
+
"GET",
|
|
1356
|
+
"/v1/sessions/:sid/snapshot",
|
|
1357
|
+
path={"sid": sid},
|
|
1358
|
+
query=query,
|
|
1359
|
+
timeout=timeout,
|
|
1360
|
+
)
|
|
1361
|
+
return response
|
|
1362
|
+
|
|
1363
|
+
def post_session_speech(
|
|
1364
|
+
self,
|
|
1365
|
+
sid: str,
|
|
1366
|
+
*,
|
|
1367
|
+
query: Query | None = None,
|
|
1368
|
+
timeout: float | None = None,
|
|
1369
|
+
body: JSONValue = None,
|
|
1370
|
+
) -> _types.VoiceJob:
|
|
1371
|
+
"""POST /v1/sessions/:sid/speech — json response."""
|
|
1372
|
+
response = self._client._request(
|
|
1373
|
+
"POST",
|
|
1374
|
+
"/v1/sessions/:sid/speech",
|
|
1375
|
+
path={"sid": sid},
|
|
1376
|
+
query=query,
|
|
1377
|
+
timeout=timeout,
|
|
1378
|
+
body=body,
|
|
1379
|
+
)
|
|
1380
|
+
return response.json()
|
|
1381
|
+
|
|
1382
|
+
def delete_session_speech_job(
|
|
1383
|
+
self,
|
|
1384
|
+
sid: str,
|
|
1385
|
+
job_id: str,
|
|
1386
|
+
*,
|
|
1387
|
+
query: Query | None = None,
|
|
1388
|
+
timeout: float | None = None,
|
|
1389
|
+
) -> _types.Forgotten:
|
|
1390
|
+
"""DELETE /v1/sessions/:sid/speech/jobs/:job-id — json response."""
|
|
1391
|
+
response = self._client._request(
|
|
1392
|
+
"DELETE",
|
|
1393
|
+
"/v1/sessions/:sid/speech/jobs/:job-id",
|
|
1394
|
+
path={"sid": sid, "job-id": job_id},
|
|
1395
|
+
query=query,
|
|
1396
|
+
timeout=timeout,
|
|
1397
|
+
)
|
|
1398
|
+
return response.json()
|
|
1399
|
+
|
|
1400
|
+
def get_session_speech_job(
|
|
1401
|
+
self,
|
|
1402
|
+
sid: str,
|
|
1403
|
+
job_id: str,
|
|
1404
|
+
*,
|
|
1405
|
+
query: Query | None = None,
|
|
1406
|
+
timeout: float | None = None,
|
|
1407
|
+
) -> _types.VoiceJob:
|
|
1408
|
+
"""GET /v1/sessions/:sid/speech/jobs/:job-id — json response."""
|
|
1409
|
+
response = self._client._request(
|
|
1410
|
+
"GET",
|
|
1411
|
+
"/v1/sessions/:sid/speech/jobs/:job-id",
|
|
1412
|
+
path={"sid": sid, "job-id": job_id},
|
|
1413
|
+
query=query,
|
|
1414
|
+
timeout=timeout,
|
|
1415
|
+
)
|
|
1416
|
+
return response.json()
|
|
1417
|
+
|
|
1418
|
+
def get_session_speech_job_audio(
|
|
1419
|
+
self,
|
|
1420
|
+
sid: str,
|
|
1421
|
+
job_id: str,
|
|
1422
|
+
*,
|
|
1423
|
+
query: Query | None = None,
|
|
1424
|
+
timeout: float | None = None,
|
|
1425
|
+
) -> Response:
|
|
1426
|
+
"""GET /v1/sessions/:sid/speech/jobs/:job-id/audio — binary response."""
|
|
1427
|
+
response = self._client._request(
|
|
1428
|
+
"GET",
|
|
1429
|
+
"/v1/sessions/:sid/speech/jobs/:job-id/audio",
|
|
1430
|
+
path={"sid": sid, "job-id": job_id},
|
|
1431
|
+
query=query,
|
|
1432
|
+
timeout=timeout,
|
|
1433
|
+
)
|
|
1434
|
+
return response
|
|
1435
|
+
|
|
1436
|
+
def get_session_suggest(
|
|
1437
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1438
|
+
) -> _types.SessionSuggestions:
|
|
1439
|
+
"""GET /v1/sessions/:sid/suggest — json response."""
|
|
1440
|
+
response = self._client._request(
|
|
1441
|
+
"GET",
|
|
1442
|
+
"/v1/sessions/:sid/suggest",
|
|
1443
|
+
path={"sid": sid},
|
|
1444
|
+
query=query,
|
|
1445
|
+
timeout=timeout,
|
|
1446
|
+
)
|
|
1447
|
+
return response.json()
|
|
1448
|
+
|
|
1449
|
+
def get_session_transcript(
|
|
1450
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1451
|
+
) -> _types.TranscriptRecord:
|
|
1452
|
+
"""GET /v1/sessions/:sid/transcript — json response."""
|
|
1453
|
+
response = self._client._request(
|
|
1454
|
+
"GET",
|
|
1455
|
+
"/v1/sessions/:sid/transcript",
|
|
1456
|
+
path={"sid": sid},
|
|
1457
|
+
query=query,
|
|
1458
|
+
timeout=timeout,
|
|
1459
|
+
)
|
|
1460
|
+
return response.json()
|
|
1461
|
+
|
|
1462
|
+
def get_session_transcript_html(
|
|
1463
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1464
|
+
) -> Response:
|
|
1465
|
+
"""GET /v1/sessions/:sid/transcript.html — html response."""
|
|
1466
|
+
response = self._client._request(
|
|
1467
|
+
"GET",
|
|
1468
|
+
"/v1/sessions/:sid/transcript.html",
|
|
1469
|
+
path={"sid": sid},
|
|
1470
|
+
query=query,
|
|
1471
|
+
timeout=timeout,
|
|
1472
|
+
)
|
|
1473
|
+
return response
|
|
1474
|
+
|
|
1475
|
+
def get_session_transcript_md(
|
|
1476
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1477
|
+
) -> Response:
|
|
1478
|
+
"""GET /v1/sessions/:sid/transcript.md — markdown response."""
|
|
1479
|
+
response = self._client._request(
|
|
1480
|
+
"GET",
|
|
1481
|
+
"/v1/sessions/:sid/transcript.md",
|
|
1482
|
+
path={"sid": sid},
|
|
1483
|
+
query=query,
|
|
1484
|
+
timeout=timeout,
|
|
1485
|
+
)
|
|
1486
|
+
return response
|
|
1487
|
+
|
|
1488
|
+
def get_session_turns(
|
|
1489
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1490
|
+
) -> _types.TurnList:
|
|
1491
|
+
"""GET /v1/sessions/:sid/turns — json response."""
|
|
1492
|
+
response = self._client._request(
|
|
1493
|
+
"GET",
|
|
1494
|
+
"/v1/sessions/:sid/turns",
|
|
1495
|
+
path={"sid": sid},
|
|
1496
|
+
query=query,
|
|
1497
|
+
timeout=timeout,
|
|
1498
|
+
)
|
|
1499
|
+
return response.json()
|
|
1500
|
+
|
|
1501
|
+
def post_session_turns(
|
|
1502
|
+
self,
|
|
1503
|
+
sid: str,
|
|
1504
|
+
*,
|
|
1505
|
+
query: Query | None = None,
|
|
1506
|
+
timeout: float | None = None,
|
|
1507
|
+
body: JSONValue = None,
|
|
1508
|
+
) -> _types.TurnRecord:
|
|
1509
|
+
"""POST /v1/sessions/:sid/turns — json response."""
|
|
1510
|
+
response = self._client._request(
|
|
1511
|
+
"POST",
|
|
1512
|
+
"/v1/sessions/:sid/turns",
|
|
1513
|
+
path={"sid": sid},
|
|
1514
|
+
query=query,
|
|
1515
|
+
timeout=timeout,
|
|
1516
|
+
body=body,
|
|
1517
|
+
)
|
|
1518
|
+
return response.json()
|
|
1519
|
+
|
|
1520
|
+
def delete_session_turn(
|
|
1521
|
+
self,
|
|
1522
|
+
sid: str,
|
|
1523
|
+
tid: str,
|
|
1524
|
+
*,
|
|
1525
|
+
query: Query | None = None,
|
|
1526
|
+
timeout: float | None = None,
|
|
1527
|
+
) -> _types.TurnCancel:
|
|
1528
|
+
"""DELETE /v1/sessions/:sid/turns/:tid — json response."""
|
|
1529
|
+
response = self._client._request(
|
|
1530
|
+
"DELETE",
|
|
1531
|
+
"/v1/sessions/:sid/turns/:tid",
|
|
1532
|
+
path={"sid": sid, "tid": tid},
|
|
1533
|
+
query=query,
|
|
1534
|
+
timeout=timeout,
|
|
1535
|
+
)
|
|
1536
|
+
return response.json()
|
|
1537
|
+
|
|
1538
|
+
def get_session_turn(
|
|
1539
|
+
self,
|
|
1540
|
+
sid: str,
|
|
1541
|
+
tid: str,
|
|
1542
|
+
*,
|
|
1543
|
+
query: Query | None = None,
|
|
1544
|
+
timeout: float | None = None,
|
|
1545
|
+
) -> _types.TurnRecord:
|
|
1546
|
+
"""GET /v1/sessions/:sid/turns/:tid — json response."""
|
|
1547
|
+
response = self._client._request(
|
|
1548
|
+
"GET",
|
|
1549
|
+
"/v1/sessions/:sid/turns/:tid",
|
|
1550
|
+
path={"sid": sid, "tid": tid},
|
|
1551
|
+
query=query,
|
|
1552
|
+
timeout=timeout,
|
|
1553
|
+
)
|
|
1554
|
+
return response.json()
|
|
1555
|
+
|
|
1556
|
+
def patch_session_turn(
|
|
1557
|
+
self,
|
|
1558
|
+
sid: str,
|
|
1559
|
+
tid: str,
|
|
1560
|
+
*,
|
|
1561
|
+
query: Query | None = None,
|
|
1562
|
+
timeout: float | None = None,
|
|
1563
|
+
body: JSONValue = None,
|
|
1564
|
+
) -> _types.TurnRecord:
|
|
1565
|
+
"""PATCH /v1/sessions/:sid/turns/:tid — json response."""
|
|
1566
|
+
response = self._client._request(
|
|
1567
|
+
"PATCH",
|
|
1568
|
+
"/v1/sessions/:sid/turns/:tid",
|
|
1569
|
+
path={"sid": sid, "tid": tid},
|
|
1570
|
+
query=query,
|
|
1571
|
+
timeout=timeout,
|
|
1572
|
+
body=body,
|
|
1573
|
+
)
|
|
1574
|
+
return response.json()
|
|
1575
|
+
|
|
1576
|
+
def get_session_turn_attachments(
|
|
1577
|
+
self,
|
|
1578
|
+
sid: str,
|
|
1579
|
+
tid: str,
|
|
1580
|
+
*,
|
|
1581
|
+
query: Query | None = None,
|
|
1582
|
+
timeout: float | None = None,
|
|
1583
|
+
) -> _types.TurnAttachments:
|
|
1584
|
+
"""GET /v1/sessions/:sid/turns/:tid/attachments — json response."""
|
|
1585
|
+
response = self._client._request(
|
|
1586
|
+
"GET",
|
|
1587
|
+
"/v1/sessions/:sid/turns/:tid/attachments",
|
|
1588
|
+
path={"sid": sid, "tid": tid},
|
|
1589
|
+
query=query,
|
|
1590
|
+
timeout=timeout,
|
|
1591
|
+
)
|
|
1592
|
+
return response.json()
|
|
1593
|
+
|
|
1594
|
+
def post_session_turn_cancel(
|
|
1595
|
+
self,
|
|
1596
|
+
sid: str,
|
|
1597
|
+
tid: str,
|
|
1598
|
+
*,
|
|
1599
|
+
query: Query | None = None,
|
|
1600
|
+
timeout: float | None = None,
|
|
1601
|
+
) -> _types.TurnCancel:
|
|
1602
|
+
"""POST /v1/sessions/:sid/turns/:tid/cancel — json response."""
|
|
1603
|
+
response = self._client._request(
|
|
1604
|
+
"POST",
|
|
1605
|
+
"/v1/sessions/:sid/turns/:tid/cancel",
|
|
1606
|
+
path={"sid": sid, "tid": tid},
|
|
1607
|
+
query=query,
|
|
1608
|
+
timeout=timeout,
|
|
1609
|
+
)
|
|
1610
|
+
return response.json()
|
|
1611
|
+
|
|
1612
|
+
def get_session_turn_trace(
|
|
1613
|
+
self,
|
|
1614
|
+
sid: str,
|
|
1615
|
+
tid: str,
|
|
1616
|
+
*,
|
|
1617
|
+
query: Query | None = None,
|
|
1618
|
+
timeout: float | None = None,
|
|
1619
|
+
) -> _types.TurnTrace:
|
|
1620
|
+
"""GET /v1/sessions/:sid/turns/:tid/trace — json response."""
|
|
1621
|
+
response = self._client._request(
|
|
1622
|
+
"GET",
|
|
1623
|
+
"/v1/sessions/:sid/turns/:tid/trace",
|
|
1624
|
+
path={"sid": sid, "tid": tid},
|
|
1625
|
+
query=query,
|
|
1626
|
+
timeout=timeout,
|
|
1627
|
+
)
|
|
1628
|
+
return response.json()
|
|
1629
|
+
|
|
1630
|
+
def get_session_usage(
|
|
1631
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1632
|
+
) -> _types.SessionUsage:
|
|
1633
|
+
"""GET /v1/sessions/:sid/usage — json response."""
|
|
1634
|
+
response = self._client._request(
|
|
1635
|
+
"GET",
|
|
1636
|
+
"/v1/sessions/:sid/usage",
|
|
1637
|
+
path={"sid": sid},
|
|
1638
|
+
query=query,
|
|
1639
|
+
timeout=timeout,
|
|
1640
|
+
)
|
|
1641
|
+
return response.json()
|
|
1642
|
+
|
|
1643
|
+
def post_session_view(
|
|
1644
|
+
self,
|
|
1645
|
+
sid: str,
|
|
1646
|
+
view_id: str,
|
|
1647
|
+
*,
|
|
1648
|
+
query: Query | None = None,
|
|
1649
|
+
timeout: float | None = None,
|
|
1650
|
+
body: JSONValue = None,
|
|
1651
|
+
) -> _types.ViewOutcome:
|
|
1652
|
+
"""POST /v1/sessions/:sid/views/:view-id/actions — json response."""
|
|
1653
|
+
response = self._client._request(
|
|
1654
|
+
"POST",
|
|
1655
|
+
"/v1/sessions/:sid/views/:view-id/actions",
|
|
1656
|
+
path={"sid": sid, "view-id": view_id},
|
|
1657
|
+
query=query,
|
|
1658
|
+
timeout=timeout,
|
|
1659
|
+
body=body,
|
|
1660
|
+
)
|
|
1661
|
+
return response.json()
|
|
1662
|
+
|
|
1663
|
+
def get_session_views_input(
|
|
1664
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1665
|
+
) -> _types.ViewRequests:
|
|
1666
|
+
"""GET /v1/sessions/:sid/views/input — json response."""
|
|
1667
|
+
response = self._client._request(
|
|
1668
|
+
"GET",
|
|
1669
|
+
"/v1/sessions/:sid/views/input",
|
|
1670
|
+
path={"sid": sid},
|
|
1671
|
+
query=query,
|
|
1672
|
+
timeout=timeout,
|
|
1673
|
+
)
|
|
1674
|
+
return response.json()
|
|
1675
|
+
|
|
1676
|
+
def get_session_views_live(
|
|
1677
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1678
|
+
) -> _types.AppList:
|
|
1679
|
+
"""GET /v1/sessions/:sid/views/live — json response."""
|
|
1680
|
+
response = self._client._request(
|
|
1681
|
+
"GET",
|
|
1682
|
+
"/v1/sessions/:sid/views/live",
|
|
1683
|
+
path={"sid": sid},
|
|
1684
|
+
query=query,
|
|
1685
|
+
timeout=timeout,
|
|
1686
|
+
)
|
|
1687
|
+
return response.json()
|
|
1688
|
+
|
|
1689
|
+
def get_session_views_live_view(
|
|
1690
|
+
self,
|
|
1691
|
+
sid: str,
|
|
1692
|
+
view_id: str,
|
|
1693
|
+
*,
|
|
1694
|
+
query: Query | None = None,
|
|
1695
|
+
timeout: float | None = None,
|
|
1696
|
+
) -> _types.AppView:
|
|
1697
|
+
"""GET /v1/sessions/:sid/views/live/:view-id — json response."""
|
|
1698
|
+
response = self._client._request(
|
|
1699
|
+
"GET",
|
|
1700
|
+
"/v1/sessions/:sid/views/live/:view-id",
|
|
1701
|
+
path={"sid": sid, "view-id": view_id},
|
|
1702
|
+
query=query,
|
|
1703
|
+
timeout=timeout,
|
|
1704
|
+
)
|
|
1705
|
+
return response.json()
|
|
1706
|
+
|
|
1707
|
+
def get_session_views_live_log(
|
|
1708
|
+
self,
|
|
1709
|
+
sid: str,
|
|
1710
|
+
view_id: str,
|
|
1711
|
+
node_id: str,
|
|
1712
|
+
*,
|
|
1713
|
+
query: Query | None = None,
|
|
1714
|
+
timeout: float | None = None,
|
|
1715
|
+
) -> _types.ViewLog:
|
|
1716
|
+
"""GET /v1/sessions/:sid/views/live/:view-id/log — json response.
|
|
1717
|
+
|
|
1718
|
+
The node rides the query string: node ids are free text a surface chose
|
|
1719
|
+
and may hold ``/``, which a path segment cannot carry.
|
|
1720
|
+
"""
|
|
1721
|
+
response = self._client._request(
|
|
1722
|
+
"GET",
|
|
1723
|
+
"/v1/sessions/:sid/views/live/:view-id/log",
|
|
1724
|
+
path={"sid": sid, "view-id": view_id},
|
|
1725
|
+
query={"node": node_id, **(query or {})},
|
|
1726
|
+
timeout=timeout,
|
|
1727
|
+
)
|
|
1728
|
+
return response.json()
|
|
1729
|
+
|
|
1730
|
+
def post_session_apps(
|
|
1731
|
+
self,
|
|
1732
|
+
sid: str,
|
|
1733
|
+
*,
|
|
1734
|
+
query: Query | None = None,
|
|
1735
|
+
timeout: float | None = None,
|
|
1736
|
+
body: JSONValue = None,
|
|
1737
|
+
) -> _types.AppDoorAnswer:
|
|
1738
|
+
"""POST /v1/sessions/:sid/apps — json response."""
|
|
1739
|
+
response = self._client._request(
|
|
1740
|
+
"POST",
|
|
1741
|
+
"/v1/sessions/:sid/apps",
|
|
1742
|
+
path={"sid": sid},
|
|
1743
|
+
query=query,
|
|
1744
|
+
timeout=timeout,
|
|
1745
|
+
body=body,
|
|
1746
|
+
)
|
|
1747
|
+
return response.json()
|
|
1748
|
+
|
|
1749
|
+
def get_apps(
|
|
1750
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
1751
|
+
) -> _types.AppList:
|
|
1752
|
+
"""GET /v1/apps — json response."""
|
|
1753
|
+
response = self._client._request(
|
|
1754
|
+
"GET", "/v1/apps", path={}, query=query, timeout=timeout
|
|
1755
|
+
)
|
|
1756
|
+
return response.json()
|
|
1757
|
+
|
|
1758
|
+
def post_apps(
|
|
1759
|
+
self,
|
|
1760
|
+
*,
|
|
1761
|
+
query: Query | None = None,
|
|
1762
|
+
timeout: float | None = None,
|
|
1763
|
+
body: JSONValue = None,
|
|
1764
|
+
) -> _types.AppDoorAnswer:
|
|
1765
|
+
"""POST /v1/apps — json response."""
|
|
1766
|
+
response = self._client._request(
|
|
1767
|
+
"POST", "/v1/apps", path={}, query=query, timeout=timeout, body=body
|
|
1768
|
+
)
|
|
1769
|
+
return response.json()
|
|
1770
|
+
|
|
1771
|
+
def get_app(
|
|
1772
|
+
self, view_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
1773
|
+
) -> _types.AppView:
|
|
1774
|
+
"""GET /v1/apps/:view-id — json response."""
|
|
1775
|
+
response = self._client._request(
|
|
1776
|
+
"GET",
|
|
1777
|
+
"/v1/apps/:view-id",
|
|
1778
|
+
path={"view-id": view_id},
|
|
1779
|
+
query=query,
|
|
1780
|
+
timeout=timeout,
|
|
1781
|
+
)
|
|
1782
|
+
return response.json()
|
|
1783
|
+
|
|
1784
|
+
def post_app_actions(
|
|
1785
|
+
self,
|
|
1786
|
+
view_id: str,
|
|
1787
|
+
*,
|
|
1788
|
+
query: Query | None = None,
|
|
1789
|
+
timeout: float | None = None,
|
|
1790
|
+
body: JSONValue = None,
|
|
1791
|
+
) -> _types.ViewOutcome:
|
|
1792
|
+
"""POST /v1/apps/:view-id/actions — json response."""
|
|
1793
|
+
response = self._client._request(
|
|
1794
|
+
"POST",
|
|
1795
|
+
"/v1/apps/:view-id/actions",
|
|
1796
|
+
path={"view-id": view_id},
|
|
1797
|
+
query=query,
|
|
1798
|
+
timeout=timeout,
|
|
1799
|
+
body=body,
|
|
1800
|
+
)
|
|
1801
|
+
return response.json()
|
|
1802
|
+
|
|
1803
|
+
def get_web_brand(
|
|
1804
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
1805
|
+
) -> _types.WebBrand:
|
|
1806
|
+
"""GET /v1/web/brand — json response."""
|
|
1807
|
+
response = self._client._request(
|
|
1808
|
+
"GET", "/v1/web/brand", path={}, query=query, timeout=timeout
|
|
1809
|
+
)
|
|
1810
|
+
return response.json()
|
|
1811
|
+
|
|
1812
|
+
def put_web_brand(
|
|
1813
|
+
self,
|
|
1814
|
+
*,
|
|
1815
|
+
query: Query | None = None,
|
|
1816
|
+
timeout: float | None = None,
|
|
1817
|
+
body: JSONValue = None,
|
|
1818
|
+
) -> _types.WebBrand:
|
|
1819
|
+
"""PUT /v1/web/brand — json response."""
|
|
1820
|
+
response = self._client._request(
|
|
1821
|
+
"PUT", "/v1/web/brand", path={}, query=query, timeout=timeout, body=body
|
|
1822
|
+
)
|
|
1823
|
+
return response.json()
|
|
1824
|
+
|
|
1825
|
+
def delete_web_brand(
|
|
1826
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
1827
|
+
) -> None:
|
|
1828
|
+
"""DELETE /v1/web/brand — empty response."""
|
|
1829
|
+
self._client._request(
|
|
1830
|
+
"DELETE", "/v1/web/brand", path={}, query=query, timeout=timeout
|
|
1831
|
+
)
|
|
1832
|
+
return None
|
|
1833
|
+
|
|
1834
|
+
def post_session_voice(
|
|
1835
|
+
self,
|
|
1836
|
+
sid: str,
|
|
1837
|
+
*,
|
|
1838
|
+
query: Query | None = None,
|
|
1839
|
+
timeout: float | None = None,
|
|
1840
|
+
content: bytes | None,
|
|
1841
|
+
) -> _types.VoiceJob:
|
|
1842
|
+
"""POST /v1/sessions/:sid/voice — json response."""
|
|
1843
|
+
response = self._client._request(
|
|
1844
|
+
"POST",
|
|
1845
|
+
"/v1/sessions/:sid/voice",
|
|
1846
|
+
path={"sid": sid},
|
|
1847
|
+
query=query,
|
|
1848
|
+
timeout=timeout,
|
|
1849
|
+
content=content,
|
|
1850
|
+
)
|
|
1851
|
+
return response.json()
|
|
1852
|
+
|
|
1853
|
+
def delete_session_voice_job(
|
|
1854
|
+
self,
|
|
1855
|
+
sid: str,
|
|
1856
|
+
job_id: str,
|
|
1857
|
+
*,
|
|
1858
|
+
query: Query | None = None,
|
|
1859
|
+
timeout: float | None = None,
|
|
1860
|
+
) -> _types.Forgotten:
|
|
1861
|
+
"""DELETE /v1/sessions/:sid/voice/jobs/:job-id — json response."""
|
|
1862
|
+
response = self._client._request(
|
|
1863
|
+
"DELETE",
|
|
1864
|
+
"/v1/sessions/:sid/voice/jobs/:job-id",
|
|
1865
|
+
path={"sid": sid, "job-id": job_id},
|
|
1866
|
+
query=query,
|
|
1867
|
+
timeout=timeout,
|
|
1868
|
+
)
|
|
1869
|
+
return response.json()
|
|
1870
|
+
|
|
1871
|
+
def get_session_voice_job(
|
|
1872
|
+
self,
|
|
1873
|
+
sid: str,
|
|
1874
|
+
job_id: str,
|
|
1875
|
+
*,
|
|
1876
|
+
query: Query | None = None,
|
|
1877
|
+
timeout: float | None = None,
|
|
1878
|
+
) -> _types.VoiceJob:
|
|
1879
|
+
"""GET /v1/sessions/:sid/voice/jobs/:job-id — json response."""
|
|
1880
|
+
response = self._client._request(
|
|
1881
|
+
"GET",
|
|
1882
|
+
"/v1/sessions/:sid/voice/jobs/:job-id",
|
|
1883
|
+
path={"sid": sid, "job-id": job_id},
|
|
1884
|
+
query=query,
|
|
1885
|
+
timeout=timeout,
|
|
1886
|
+
)
|
|
1887
|
+
return response.json()
|
|
1888
|
+
|
|
1889
|
+
def get_session_workspace(
|
|
1890
|
+
self, sid: str, *, query: Query | None = None, timeout: float | None = None
|
|
1891
|
+
) -> _types.SessionWorkspace:
|
|
1892
|
+
"""GET /v1/sessions/:sid/workspace — json response."""
|
|
1893
|
+
response = self._client._request(
|
|
1894
|
+
"GET",
|
|
1895
|
+
"/v1/sessions/:sid/workspace",
|
|
1896
|
+
path={"sid": sid},
|
|
1897
|
+
query=query,
|
|
1898
|
+
timeout=timeout,
|
|
1899
|
+
)
|
|
1900
|
+
return response.json()
|
|
1901
|
+
|
|
1902
|
+
def patch_session_workspace_root(
|
|
1903
|
+
self,
|
|
1904
|
+
sid: str,
|
|
1905
|
+
*,
|
|
1906
|
+
query: Query | None = None,
|
|
1907
|
+
timeout: float | None = None,
|
|
1908
|
+
body: JSONValue = None,
|
|
1909
|
+
) -> _types.SessionWorkspace:
|
|
1910
|
+
"""PATCH /v1/sessions/:sid/workspace/root — json response."""
|
|
1911
|
+
response = self._client._request(
|
|
1912
|
+
"PATCH",
|
|
1913
|
+
"/v1/sessions/:sid/workspace/root",
|
|
1914
|
+
path={"sid": sid},
|
|
1915
|
+
query=query,
|
|
1916
|
+
timeout=timeout,
|
|
1917
|
+
body=body,
|
|
1918
|
+
)
|
|
1919
|
+
return response.json()
|
|
1920
|
+
|
|
1921
|
+
def post_sessions_archive(
|
|
1922
|
+
self,
|
|
1923
|
+
*,
|
|
1924
|
+
query: Query | None = None,
|
|
1925
|
+
timeout: float | None = None,
|
|
1926
|
+
body: JSONValue = None,
|
|
1927
|
+
) -> _types.SessionArchive:
|
|
1928
|
+
"""POST /v1/sessions/actions/archive — archive many sessions; skip working ones."""
|
|
1929
|
+
response = self._client._request(
|
|
1930
|
+
"POST",
|
|
1931
|
+
"/v1/sessions/actions/archive",
|
|
1932
|
+
path={},
|
|
1933
|
+
query=query,
|
|
1934
|
+
timeout=timeout,
|
|
1935
|
+
body=body,
|
|
1936
|
+
)
|
|
1937
|
+
return response.json()
|
|
1938
|
+
|
|
1939
|
+
def post_sessions_import(
|
|
1940
|
+
self,
|
|
1941
|
+
*,
|
|
1942
|
+
query: Query | None = None,
|
|
1943
|
+
timeout: float | None = None,
|
|
1944
|
+
content: bytes | None,
|
|
1945
|
+
) -> _types.SessionRecord:
|
|
1946
|
+
"""POST /v1/sessions/actions/import — restore a session snapshot."""
|
|
1947
|
+
response = self._client._request(
|
|
1948
|
+
"POST",
|
|
1949
|
+
"/v1/sessions/actions/import",
|
|
1950
|
+
path={},
|
|
1951
|
+
query=query,
|
|
1952
|
+
timeout=timeout,
|
|
1953
|
+
content=content,
|
|
1954
|
+
)
|
|
1955
|
+
return response.json()
|
|
1956
|
+
|
|
1957
|
+
def get_sessions_search(
|
|
1958
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
1959
|
+
) -> _types.SessionSearch:
|
|
1960
|
+
"""GET /v1/sessions/actions/search — json response."""
|
|
1961
|
+
response = self._client._request(
|
|
1962
|
+
"GET", "/v1/sessions/actions/search", path={}, query=query, timeout=timeout
|
|
1963
|
+
)
|
|
1964
|
+
return response.json()
|
|
1965
|
+
|
|
1966
|
+
def post_machines_order(
|
|
1967
|
+
self,
|
|
1968
|
+
*,
|
|
1969
|
+
query: Query | None = None,
|
|
1970
|
+
timeout: float | None = None,
|
|
1971
|
+
body: JSONValue = None,
|
|
1972
|
+
) -> _types.MachineOrder:
|
|
1973
|
+
"""POST /v1/machines/order — register gateway IDs and return their durable order."""
|
|
1974
|
+
response = self._client._request(
|
|
1975
|
+
"POST",
|
|
1976
|
+
"/v1/machines/order",
|
|
1977
|
+
path={},
|
|
1978
|
+
query=query,
|
|
1979
|
+
timeout=timeout,
|
|
1980
|
+
body=body,
|
|
1981
|
+
)
|
|
1982
|
+
return response.json()
|
|
1983
|
+
|
|
1984
|
+
def get_automations(
|
|
1985
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
1986
|
+
) -> _types.AutomationsList:
|
|
1987
|
+
"""GET /v1/automations — json response."""
|
|
1988
|
+
response = self._client._request(
|
|
1989
|
+
"GET", "/v1/automations", path={}, query=query, timeout=timeout
|
|
1990
|
+
)
|
|
1991
|
+
return response.json()
|
|
1992
|
+
|
|
1993
|
+
def post_automations(
|
|
1994
|
+
self,
|
|
1995
|
+
*,
|
|
1996
|
+
query: Query | None = None,
|
|
1997
|
+
timeout: float | None = None,
|
|
1998
|
+
body: JSONValue = None,
|
|
1999
|
+
) -> _types.AutomationsAutomation:
|
|
2000
|
+
"""POST /v1/automations — json response."""
|
|
2001
|
+
response = self._client._request(
|
|
2002
|
+
"POST", "/v1/automations", path={}, query=query, timeout=timeout, body=body
|
|
2003
|
+
)
|
|
2004
|
+
return response.json()
|
|
2005
|
+
|
|
2006
|
+
def get_automation_runs(
|
|
2007
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2008
|
+
) -> _types.AutomationsRunList:
|
|
2009
|
+
"""GET /v1/automations/runs — json response."""
|
|
2010
|
+
response = self._client._request(
|
|
2011
|
+
"GET", "/v1/automations/runs", path={}, query=query, timeout=timeout
|
|
2012
|
+
)
|
|
2013
|
+
return response.json()
|
|
2014
|
+
|
|
2015
|
+
def get_automation_run(
|
|
2016
|
+
self, run_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2017
|
+
) -> _types.AutomationsRun:
|
|
2018
|
+
"""GET /v1/automations/runs/:run-id — json response."""
|
|
2019
|
+
response = self._client._request(
|
|
2020
|
+
"GET",
|
|
2021
|
+
"/v1/automations/runs/:run-id",
|
|
2022
|
+
path={"run-id": run_id},
|
|
2023
|
+
query=query,
|
|
2024
|
+
timeout=timeout,
|
|
2025
|
+
)
|
|
2026
|
+
return response.json()
|
|
2027
|
+
|
|
2028
|
+
def get_automation(
|
|
2029
|
+
self,
|
|
2030
|
+
automation_id: str,
|
|
2031
|
+
*,
|
|
2032
|
+
query: Query | None = None,
|
|
2033
|
+
timeout: float | None = None,
|
|
2034
|
+
) -> _types.AutomationsAutomation:
|
|
2035
|
+
"""GET /v1/automations/:automation-id — json response."""
|
|
2036
|
+
response = self._client._request(
|
|
2037
|
+
"GET",
|
|
2038
|
+
"/v1/automations/:automation-id",
|
|
2039
|
+
path={"automation-id": automation_id},
|
|
2040
|
+
query=query,
|
|
2041
|
+
timeout=timeout,
|
|
2042
|
+
)
|
|
2043
|
+
return response.json()
|
|
2044
|
+
|
|
2045
|
+
def patch_automation(
|
|
2046
|
+
self,
|
|
2047
|
+
automation_id: str,
|
|
2048
|
+
*,
|
|
2049
|
+
query: Query | None = None,
|
|
2050
|
+
timeout: float | None = None,
|
|
2051
|
+
body: JSONValue = None,
|
|
2052
|
+
) -> _types.AutomationsAutomation:
|
|
2053
|
+
"""PATCH /v1/automations/:automation-id — json response."""
|
|
2054
|
+
response = self._client._request(
|
|
2055
|
+
"PATCH",
|
|
2056
|
+
"/v1/automations/:automation-id",
|
|
2057
|
+
path={"automation-id": automation_id},
|
|
2058
|
+
query=query,
|
|
2059
|
+
timeout=timeout,
|
|
2060
|
+
body=body,
|
|
2061
|
+
)
|
|
2062
|
+
return response.json()
|
|
2063
|
+
|
|
2064
|
+
def delete_automation(
|
|
2065
|
+
self,
|
|
2066
|
+
automation_id: str,
|
|
2067
|
+
*,
|
|
2068
|
+
query: Query | None = None,
|
|
2069
|
+
timeout: float | None = None,
|
|
2070
|
+
) -> _types.AutomationsDeleted:
|
|
2071
|
+
"""DELETE /v1/automations/:automation-id — json response."""
|
|
2072
|
+
response = self._client._request(
|
|
2073
|
+
"DELETE",
|
|
2074
|
+
"/v1/automations/:automation-id",
|
|
2075
|
+
path={"automation-id": automation_id},
|
|
2076
|
+
query=query,
|
|
2077
|
+
timeout=timeout,
|
|
2078
|
+
)
|
|
2079
|
+
return response.json()
|
|
2080
|
+
|
|
2081
|
+
def post_automation_run(
|
|
2082
|
+
self,
|
|
2083
|
+
automation_id: str,
|
|
2084
|
+
*,
|
|
2085
|
+
query: Query | None = None,
|
|
2086
|
+
timeout: float | None = None,
|
|
2087
|
+
) -> _types.AutomationsRun:
|
|
2088
|
+
"""POST /v1/automations/:automation-id/run — json response."""
|
|
2089
|
+
response = self._client._request(
|
|
2090
|
+
"POST",
|
|
2091
|
+
"/v1/automations/:automation-id/run",
|
|
2092
|
+
path={"automation-id": automation_id},
|
|
2093
|
+
query=query,
|
|
2094
|
+
timeout=timeout,
|
|
2095
|
+
)
|
|
2096
|
+
return response.json()
|
|
2097
|
+
|
|
2098
|
+
def post_automation_secrets(
|
|
2099
|
+
self,
|
|
2100
|
+
automation_id: str,
|
|
2101
|
+
*,
|
|
2102
|
+
query: Query | None = None,
|
|
2103
|
+
timeout: float | None = None,
|
|
2104
|
+
body: JSONValue = None,
|
|
2105
|
+
) -> _types.AutomationsSecretCreated:
|
|
2106
|
+
"""POST /v1/automations/:automation-id/secrets — json response."""
|
|
2107
|
+
response = self._client._request(
|
|
2108
|
+
"POST",
|
|
2109
|
+
"/v1/automations/:automation-id/secrets",
|
|
2110
|
+
path={"automation-id": automation_id},
|
|
2111
|
+
query=query,
|
|
2112
|
+
timeout=timeout,
|
|
2113
|
+
body=body,
|
|
2114
|
+
)
|
|
2115
|
+
return response.json()
|
|
2116
|
+
|
|
2117
|
+
def post_evals_agreement(
|
|
2118
|
+
self,
|
|
2119
|
+
*,
|
|
2120
|
+
query: Query | None = None,
|
|
2121
|
+
timeout: float | None = None,
|
|
2122
|
+
body: JSONValue = None,
|
|
2123
|
+
) -> _types.EvalsAgreement:
|
|
2124
|
+
"""POST /v1/evals/agreement — json response."""
|
|
2125
|
+
response = self._client._request(
|
|
2126
|
+
"POST",
|
|
2127
|
+
"/v1/evals/agreement",
|
|
2128
|
+
path={},
|
|
2129
|
+
query=query,
|
|
2130
|
+
timeout=timeout,
|
|
2131
|
+
body=body,
|
|
2132
|
+
)
|
|
2133
|
+
return response.json()
|
|
2134
|
+
|
|
2135
|
+
def post_evals_compare(
|
|
2136
|
+
self,
|
|
2137
|
+
*,
|
|
2138
|
+
query: Query | None = None,
|
|
2139
|
+
timeout: float | None = None,
|
|
2140
|
+
body: JSONValue = None,
|
|
2141
|
+
) -> _types.EvalsCaseComparison:
|
|
2142
|
+
"""POST /v1/evals/compare — json response."""
|
|
2143
|
+
response = self._client._request(
|
|
2144
|
+
"POST",
|
|
2145
|
+
"/v1/evals/compare",
|
|
2146
|
+
path={},
|
|
2147
|
+
query=query,
|
|
2148
|
+
timeout=timeout,
|
|
2149
|
+
body=body,
|
|
2150
|
+
)
|
|
2151
|
+
return response.json()
|
|
2152
|
+
|
|
2153
|
+
def post_evals_diagnose(
|
|
2154
|
+
self,
|
|
2155
|
+
*,
|
|
2156
|
+
query: Query | None = None,
|
|
2157
|
+
timeout: float | None = None,
|
|
2158
|
+
body: JSONValue = None,
|
|
2159
|
+
) -> _types.EvalsDiagnosis:
|
|
2160
|
+
"""POST /v1/evals/diagnose — json response."""
|
|
2161
|
+
response = self._client._request(
|
|
2162
|
+
"POST",
|
|
2163
|
+
"/v1/evals/diagnose",
|
|
2164
|
+
path={},
|
|
2165
|
+
query=query,
|
|
2166
|
+
timeout=timeout,
|
|
2167
|
+
body=body,
|
|
2168
|
+
)
|
|
2169
|
+
return response.json()
|
|
2170
|
+
|
|
2171
|
+
def post_evals_labels(
|
|
2172
|
+
self,
|
|
2173
|
+
*,
|
|
2174
|
+
query: Query | None = None,
|
|
2175
|
+
timeout: float | None = None,
|
|
2176
|
+
body: JSONValue = None,
|
|
2177
|
+
) -> _types.EvalsAgreement:
|
|
2178
|
+
"""POST /v1/evals/labels — json response."""
|
|
2179
|
+
response = self._client._request(
|
|
2180
|
+
"POST", "/v1/evals/labels", path={}, query=query, timeout=timeout, body=body
|
|
2181
|
+
)
|
|
2182
|
+
return response.json()
|
|
2183
|
+
|
|
2184
|
+
def post_evals_leaderboard(
|
|
2185
|
+
self,
|
|
2186
|
+
*,
|
|
2187
|
+
query: Query | None = None,
|
|
2188
|
+
timeout: float | None = None,
|
|
2189
|
+
body: JSONValue = None,
|
|
2190
|
+
) -> _types.EvalsLeaderboard:
|
|
2191
|
+
"""POST /v1/evals/leaderboard — json response."""
|
|
2192
|
+
response = self._client._request(
|
|
2193
|
+
"POST",
|
|
2194
|
+
"/v1/evals/leaderboard",
|
|
2195
|
+
path={},
|
|
2196
|
+
query=query,
|
|
2197
|
+
timeout=timeout,
|
|
2198
|
+
body=body,
|
|
2199
|
+
)
|
|
2200
|
+
return response.json()
|
|
2201
|
+
|
|
2202
|
+
def post_evals_report(
|
|
2203
|
+
self,
|
|
2204
|
+
*,
|
|
2205
|
+
query: Query | None = None,
|
|
2206
|
+
timeout: float | None = None,
|
|
2207
|
+
body: JSONValue = None,
|
|
2208
|
+
) -> _types.EvalsBenchReport:
|
|
2209
|
+
"""POST /v1/evals/report — json response."""
|
|
2210
|
+
response = self._client._request(
|
|
2211
|
+
"POST", "/v1/evals/report", path={}, query=query, timeout=timeout, body=body
|
|
2212
|
+
)
|
|
2213
|
+
return response.json()
|
|
2214
|
+
|
|
2215
|
+
def get_settings(
|
|
2216
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2217
|
+
) -> _types.Settings:
|
|
2218
|
+
"""GET /v1/settings — json response."""
|
|
2219
|
+
response = self._client._request(
|
|
2220
|
+
"GET", "/v1/settings", path={}, query=query, timeout=timeout
|
|
2221
|
+
)
|
|
2222
|
+
return response.json()
|
|
2223
|
+
|
|
2224
|
+
def post_settings(
|
|
2225
|
+
self,
|
|
2226
|
+
*,
|
|
2227
|
+
query: Query | None = None,
|
|
2228
|
+
timeout: float | None = None,
|
|
2229
|
+
body: JSONValue = None,
|
|
2230
|
+
) -> _types.Setting:
|
|
2231
|
+
"""POST /v1/settings — json response."""
|
|
2232
|
+
response = self._client._request(
|
|
2233
|
+
"POST", "/v1/settings", path={}, query=query, timeout=timeout, body=body
|
|
2234
|
+
)
|
|
2235
|
+
return response.json()
|
|
2236
|
+
|
|
2237
|
+
def patch_settings(
|
|
2238
|
+
self,
|
|
2239
|
+
*,
|
|
2240
|
+
query: Query | None = None,
|
|
2241
|
+
timeout: float | None = None,
|
|
2242
|
+
body: JSONValue = None,
|
|
2243
|
+
) -> _types.Settings:
|
|
2244
|
+
"""PATCH /v1/settings — json response."""
|
|
2245
|
+
response = self._client._request(
|
|
2246
|
+
"PATCH", "/v1/settings", path={}, query=query, timeout=timeout, body=body
|
|
2247
|
+
)
|
|
2248
|
+
return response.json()
|
|
2249
|
+
|
|
2250
|
+
def get_setting(
|
|
2251
|
+
self, id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2252
|
+
) -> _types.Setting:
|
|
2253
|
+
"""GET /v1/settings/:id — json response."""
|
|
2254
|
+
response = self._client._request(
|
|
2255
|
+
"GET", "/v1/settings/:id", path={"id": id}, query=query, timeout=timeout
|
|
2256
|
+
)
|
|
2257
|
+
return response.json()
|
|
2258
|
+
|
|
2259
|
+
def post_setting_preview(
|
|
2260
|
+
self,
|
|
2261
|
+
id: str,
|
|
2262
|
+
*,
|
|
2263
|
+
query: Query | None = None,
|
|
2264
|
+
timeout: float | None = None,
|
|
2265
|
+
body: JSONValue = None,
|
|
2266
|
+
) -> _types.SettingPreviewResult:
|
|
2267
|
+
"""POST /v1/settings/:id/preview — json response."""
|
|
2268
|
+
response = self._client._request(
|
|
2269
|
+
"POST",
|
|
2270
|
+
"/v1/settings/:id/preview",
|
|
2271
|
+
path={"id": id},
|
|
2272
|
+
query=query,
|
|
2273
|
+
timeout=timeout,
|
|
2274
|
+
body=body,
|
|
2275
|
+
)
|
|
2276
|
+
return response.json()
|
|
2277
|
+
|
|
2278
|
+
def post_extensions_reload(
|
|
2279
|
+
self,
|
|
2280
|
+
*,
|
|
2281
|
+
query: Query | None = None,
|
|
2282
|
+
timeout: float | None = None,
|
|
2283
|
+
body: JSONValue = None,
|
|
2284
|
+
) -> _types.ExtensionReload:
|
|
2285
|
+
"""POST /v1/extensions/reload — json response."""
|
|
2286
|
+
response = self._client._request(
|
|
2287
|
+
"POST",
|
|
2288
|
+
"/v1/extensions/reload",
|
|
2289
|
+
path={},
|
|
2290
|
+
query=query,
|
|
2291
|
+
timeout=timeout,
|
|
2292
|
+
body=body,
|
|
2293
|
+
)
|
|
2294
|
+
return response.json()
|
|
2295
|
+
|
|
2296
|
+
def post_speech(
|
|
2297
|
+
self,
|
|
2298
|
+
*,
|
|
2299
|
+
query: Query | None = None,
|
|
2300
|
+
timeout: float | None = None,
|
|
2301
|
+
body: JSONValue = None,
|
|
2302
|
+
) -> _types.VoiceJob:
|
|
2303
|
+
"""POST /v1/speech — json response."""
|
|
2304
|
+
response = self._client._request(
|
|
2305
|
+
"POST", "/v1/speech", path={}, query=query, timeout=timeout, body=body
|
|
2306
|
+
)
|
|
2307
|
+
return response.json()
|
|
2308
|
+
|
|
2309
|
+
def delete_speech_job(
|
|
2310
|
+
self, job_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2311
|
+
) -> _types.Forgotten:
|
|
2312
|
+
"""DELETE /v1/speech/jobs/:job-id — json response."""
|
|
2313
|
+
response = self._client._request(
|
|
2314
|
+
"DELETE",
|
|
2315
|
+
"/v1/speech/jobs/:job-id",
|
|
2316
|
+
path={"job-id": job_id},
|
|
2317
|
+
query=query,
|
|
2318
|
+
timeout=timeout,
|
|
2319
|
+
)
|
|
2320
|
+
return response.json()
|
|
2321
|
+
|
|
2322
|
+
def get_speech_job(
|
|
2323
|
+
self, job_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2324
|
+
) -> _types.VoiceJob:
|
|
2325
|
+
"""GET /v1/speech/jobs/:job-id — json response."""
|
|
2326
|
+
response = self._client._request(
|
|
2327
|
+
"GET",
|
|
2328
|
+
"/v1/speech/jobs/:job-id",
|
|
2329
|
+
path={"job-id": job_id},
|
|
2330
|
+
query=query,
|
|
2331
|
+
timeout=timeout,
|
|
2332
|
+
)
|
|
2333
|
+
return response.json()
|
|
2334
|
+
|
|
2335
|
+
def get_speech_job_audio(
|
|
2336
|
+
self, job_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2337
|
+
) -> Response:
|
|
2338
|
+
"""GET /v1/speech/jobs/:job-id/audio — binary response."""
|
|
2339
|
+
response = self._client._request(
|
|
2340
|
+
"GET",
|
|
2341
|
+
"/v1/speech/jobs/:job-id/audio",
|
|
2342
|
+
path={"job-id": job_id},
|
|
2343
|
+
query=query,
|
|
2344
|
+
timeout=timeout,
|
|
2345
|
+
)
|
|
2346
|
+
return response
|
|
2347
|
+
|
|
2348
|
+
def get_speech_model(
|
|
2349
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2350
|
+
) -> _types.VoiceModel:
|
|
2351
|
+
"""GET /v1/speech/model — json response."""
|
|
2352
|
+
response = self._client._request(
|
|
2353
|
+
"GET", "/v1/speech/model", path={}, query=query, timeout=timeout
|
|
2354
|
+
)
|
|
2355
|
+
return response.json()
|
|
2356
|
+
|
|
2357
|
+
def post_speech_model(
|
|
2358
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2359
|
+
) -> _types.VoiceModel:
|
|
2360
|
+
"""POST /v1/speech/model — json response."""
|
|
2361
|
+
response = self._client._request(
|
|
2362
|
+
"POST", "/v1/speech/model", path={}, query=query, timeout=timeout
|
|
2363
|
+
)
|
|
2364
|
+
return response.json()
|
|
2365
|
+
|
|
2366
|
+
def get_speech_voices(
|
|
2367
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2368
|
+
) -> _types.SpeechVoices:
|
|
2369
|
+
"""GET /v1/speech/voices — json response."""
|
|
2370
|
+
response = self._client._request(
|
|
2371
|
+
"GET", "/v1/speech/voices", path={}, query=query, timeout=timeout
|
|
2372
|
+
)
|
|
2373
|
+
return response.json()
|
|
2374
|
+
|
|
2375
|
+
def post_speech_voices(
|
|
2376
|
+
self,
|
|
2377
|
+
*,
|
|
2378
|
+
query: Query | None = None,
|
|
2379
|
+
timeout: float | None = None,
|
|
2380
|
+
content: bytes | None,
|
|
2381
|
+
) -> _types.SpeechVoice:
|
|
2382
|
+
"""POST /v1/speech/voices — json response."""
|
|
2383
|
+
response = self._client._request(
|
|
2384
|
+
"POST",
|
|
2385
|
+
"/v1/speech/voices",
|
|
2386
|
+
path={},
|
|
2387
|
+
query=query,
|
|
2388
|
+
timeout=timeout,
|
|
2389
|
+
content=content,
|
|
2390
|
+
)
|
|
2391
|
+
return response.json()
|
|
2392
|
+
|
|
2393
|
+
def delete_speech_voice(
|
|
2394
|
+
self, voice_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2395
|
+
) -> _types.Forgotten:
|
|
2396
|
+
"""DELETE /v1/speech/voices/:voice-id — json response."""
|
|
2397
|
+
response = self._client._request(
|
|
2398
|
+
"DELETE",
|
|
2399
|
+
"/v1/speech/voices/:voice-id",
|
|
2400
|
+
path={"voice-id": voice_id},
|
|
2401
|
+
query=query,
|
|
2402
|
+
timeout=timeout,
|
|
2403
|
+
)
|
|
2404
|
+
return response.json()
|
|
2405
|
+
|
|
2406
|
+
def patch_speech_voice(
|
|
2407
|
+
self,
|
|
2408
|
+
voice_id: str,
|
|
2409
|
+
*,
|
|
2410
|
+
query: Query | None = None,
|
|
2411
|
+
timeout: float | None = None,
|
|
2412
|
+
body: JSONValue = None,
|
|
2413
|
+
) -> _types.SpeechVoice:
|
|
2414
|
+
"""PATCH /v1/speech/voices/:voice-id — json response."""
|
|
2415
|
+
response = self._client._request(
|
|
2416
|
+
"PATCH",
|
|
2417
|
+
"/v1/speech/voices/:voice-id",
|
|
2418
|
+
path={"voice-id": voice_id},
|
|
2419
|
+
query=query,
|
|
2420
|
+
timeout=timeout,
|
|
2421
|
+
body=body,
|
|
2422
|
+
)
|
|
2423
|
+
return response.json()
|
|
2424
|
+
|
|
2425
|
+
def get_speech_voice_sample(
|
|
2426
|
+
self, voice_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2427
|
+
) -> Response:
|
|
2428
|
+
"""GET /v1/speech/voices/:voice-id/sample — binary response."""
|
|
2429
|
+
response = self._client._request(
|
|
2430
|
+
"GET",
|
|
2431
|
+
"/v1/speech/voices/:voice-id/sample",
|
|
2432
|
+
path={"voice-id": voice_id},
|
|
2433
|
+
query=query,
|
|
2434
|
+
timeout=timeout,
|
|
2435
|
+
)
|
|
2436
|
+
return response
|
|
2437
|
+
|
|
2438
|
+
def get_decision_models(
|
|
2439
|
+
self, *, timeout: float | None = None
|
|
2440
|
+
) -> _types.DecisionModels:
|
|
2441
|
+
"""GET /v1/decisions/models — installed and resident decision versions."""
|
|
2442
|
+
response = self._client._request(
|
|
2443
|
+
"GET", "/v1/decisions/models", path={}, timeout=timeout
|
|
2444
|
+
)
|
|
2445
|
+
return response.json()
|
|
2446
|
+
|
|
2447
|
+
def get_decision_model(
|
|
2448
|
+
self, model_ref: str, *, timeout: float | None = None
|
|
2449
|
+
) -> _types.DecisionModel:
|
|
2450
|
+
"""GET /v1/decisions/models/:model-ref — immutable status after upload."""
|
|
2451
|
+
return self._client._request(
|
|
2452
|
+
"GET",
|
|
2453
|
+
"/v1/decisions/models/:model-ref",
|
|
2454
|
+
path={"model-ref": model_ref},
|
|
2455
|
+
timeout=timeout,
|
|
2456
|
+
).json()
|
|
2457
|
+
|
|
2458
|
+
def get_decision_alias(
|
|
2459
|
+
self, alias: str, *, timeout: float | None = None
|
|
2460
|
+
) -> _types.DecisionAlias:
|
|
2461
|
+
"""GET /v1/decisions/aliases/:alias — current ref before a CAS update."""
|
|
2462
|
+
return self._client._request(
|
|
2463
|
+
"GET",
|
|
2464
|
+
"/v1/decisions/aliases/:alias",
|
|
2465
|
+
path={"alias": alias},
|
|
2466
|
+
timeout=timeout,
|
|
2467
|
+
).json()
|
|
2468
|
+
|
|
2469
|
+
def put_decision_alias(
|
|
2470
|
+
self,
|
|
2471
|
+
alias: str,
|
|
2472
|
+
*,
|
|
2473
|
+
model_ref: str,
|
|
2474
|
+
expected_current: str | None = None,
|
|
2475
|
+
timeout: float | None = None,
|
|
2476
|
+
) -> _types.DecisionAlias:
|
|
2477
|
+
"""PUT /v1/decisions/aliases/:alias — explicit compare-and-swap update."""
|
|
2478
|
+
return self._client._request(
|
|
2479
|
+
"PUT",
|
|
2480
|
+
"/v1/decisions/aliases/:alias",
|
|
2481
|
+
path={"alias": alias},
|
|
2482
|
+
body={"model_ref": model_ref, "expected_current": expected_current},
|
|
2483
|
+
timeout=timeout,
|
|
2484
|
+
).json()
|
|
2485
|
+
|
|
2486
|
+
def post_decision_training_job(
|
|
2487
|
+
self, *, body: JSONValue, timeout: float | None = None
|
|
2488
|
+
) -> _types.DecisionJob:
|
|
2489
|
+
"""POST /v1/decisions/training/jobs — train on approved local data."""
|
|
2490
|
+
return self._client._request(
|
|
2491
|
+
"POST", "/v1/decisions/training/jobs", path={}, body=body, timeout=timeout
|
|
2492
|
+
).json()
|
|
2493
|
+
|
|
2494
|
+
def get_decision_training_job(
|
|
2495
|
+
self, job_id: str, *, timeout: float | None = None
|
|
2496
|
+
) -> _types.DecisionJob:
|
|
2497
|
+
"""GET /v1/decisions/training/jobs/:job-id — durable progress."""
|
|
2498
|
+
return self._client._request(
|
|
2499
|
+
"GET",
|
|
2500
|
+
"/v1/decisions/training/jobs/:job-id",
|
|
2501
|
+
path={"job-id": job_id},
|
|
2502
|
+
timeout=timeout,
|
|
2503
|
+
).json()
|
|
2504
|
+
|
|
2505
|
+
def delete_decision_training_job(
|
|
2506
|
+
self, job_id: str, *, timeout: float | None = None
|
|
2507
|
+
) -> _types.DecisionJob:
|
|
2508
|
+
"""DELETE /v1/decisions/training/jobs/:job-id — cancel or discard."""
|
|
2509
|
+
return self._client._request(
|
|
2510
|
+
"DELETE",
|
|
2511
|
+
"/v1/decisions/training/jobs/:job-id",
|
|
2512
|
+
path={"job-id": job_id},
|
|
2513
|
+
timeout=timeout,
|
|
2514
|
+
).json()
|
|
2515
|
+
|
|
2516
|
+
def post_systemone(
|
|
2517
|
+
self, *, body: JSONValue, timeout: float | None = None
|
|
2518
|
+
) -> _types.DecisionAnswer:
|
|
2519
|
+
"""POST /v1/systemone — typed decisions from an explicitly named model."""
|
|
2520
|
+
response = self._client._request(
|
|
2521
|
+
"POST", "/v1/systemone", path={}, timeout=timeout, body=body
|
|
2522
|
+
)
|
|
2523
|
+
return response.json()
|
|
2524
|
+
|
|
2525
|
+
def post_voice(
|
|
2526
|
+
self,
|
|
2527
|
+
*,
|
|
2528
|
+
query: Query | None = None,
|
|
2529
|
+
timeout: float | None = None,
|
|
2530
|
+
content: bytes | None,
|
|
2531
|
+
) -> _types.VoiceJob:
|
|
2532
|
+
"""POST /v1/voice — json response."""
|
|
2533
|
+
response = self._client._request(
|
|
2534
|
+
"POST", "/v1/voice", path={}, query=query, timeout=timeout, content=content
|
|
2535
|
+
)
|
|
2536
|
+
return response.json()
|
|
2537
|
+
|
|
2538
|
+
def delete_voice_job(
|
|
2539
|
+
self, job_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2540
|
+
) -> _types.Forgotten:
|
|
2541
|
+
"""DELETE /v1/voice/jobs/:job-id — json response."""
|
|
2542
|
+
response = self._client._request(
|
|
2543
|
+
"DELETE",
|
|
2544
|
+
"/v1/voice/jobs/:job-id",
|
|
2545
|
+
path={"job-id": job_id},
|
|
2546
|
+
query=query,
|
|
2547
|
+
timeout=timeout,
|
|
2548
|
+
)
|
|
2549
|
+
return response.json()
|
|
2550
|
+
|
|
2551
|
+
def get_voice_live_capabilities(
|
|
2552
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2553
|
+
) -> _types.VoiceLiveCapabilities:
|
|
2554
|
+
"""GET /v1/voice/live/capabilities — json response."""
|
|
2555
|
+
response = self._client._request(
|
|
2556
|
+
"GET", "/v1/voice/live/capabilities", path={}, query=query, timeout=timeout
|
|
2557
|
+
)
|
|
2558
|
+
return response.json()
|
|
2559
|
+
|
|
2560
|
+
def post_session_voice_live(
|
|
2561
|
+
self,
|
|
2562
|
+
sid: str,
|
|
2563
|
+
*,
|
|
2564
|
+
query: Query | None = None,
|
|
2565
|
+
timeout: float | None = None,
|
|
2566
|
+
body: JSONValue = None,
|
|
2567
|
+
) -> _types.VoiceLiveStart:
|
|
2568
|
+
"""POST /v1/sessions/:sid/voice/live — json response."""
|
|
2569
|
+
response = self._client._request(
|
|
2570
|
+
"POST",
|
|
2571
|
+
"/v1/sessions/:sid/voice/live",
|
|
2572
|
+
path={"sid": sid},
|
|
2573
|
+
query=query,
|
|
2574
|
+
timeout=timeout,
|
|
2575
|
+
body=body,
|
|
2576
|
+
)
|
|
2577
|
+
return response.json()
|
|
2578
|
+
|
|
2579
|
+
def get_session_voice_live(
|
|
2580
|
+
self,
|
|
2581
|
+
sid: str,
|
|
2582
|
+
vid: str,
|
|
2583
|
+
*,
|
|
2584
|
+
query: Query | None = None,
|
|
2585
|
+
timeout: float | None = None,
|
|
2586
|
+
) -> _types.VoiceLiveSnapshot:
|
|
2587
|
+
"""GET /v1/sessions/:sid/voice/live/:vid — json response."""
|
|
2588
|
+
response = self._client._request(
|
|
2589
|
+
"GET",
|
|
2590
|
+
"/v1/sessions/:sid/voice/live/:vid",
|
|
2591
|
+
path={"sid": sid, "vid": vid},
|
|
2592
|
+
query=query,
|
|
2593
|
+
timeout=timeout,
|
|
2594
|
+
)
|
|
2595
|
+
return response.json()
|
|
2596
|
+
|
|
2597
|
+
def delete_session_voice_live(
|
|
2598
|
+
self,
|
|
2599
|
+
sid: str,
|
|
2600
|
+
vid: str,
|
|
2601
|
+
*,
|
|
2602
|
+
query: Query | None = None,
|
|
2603
|
+
timeout: float | None = None,
|
|
2604
|
+
) -> _types.VoiceLiveClosed:
|
|
2605
|
+
"""DELETE /v1/sessions/:sid/voice/live/:vid — json response."""
|
|
2606
|
+
response = self._client._request(
|
|
2607
|
+
"DELETE",
|
|
2608
|
+
"/v1/sessions/:sid/voice/live/:vid",
|
|
2609
|
+
path={"sid": sid, "vid": vid},
|
|
2610
|
+
query=query,
|
|
2611
|
+
timeout=timeout,
|
|
2612
|
+
)
|
|
2613
|
+
return response.json()
|
|
2614
|
+
|
|
2615
|
+
def get_session_voice_live_media(
|
|
2616
|
+
self,
|
|
2617
|
+
sid: str,
|
|
2618
|
+
vid: str,
|
|
2619
|
+
*,
|
|
2620
|
+
query: Query | None = None,
|
|
2621
|
+
timeout: float | None = None,
|
|
2622
|
+
) -> Response:
|
|
2623
|
+
"""GET /v1/sessions/:sid/voice/live/:vid/media — WebSocket media is not supported by this SDK."""
|
|
2624
|
+
response = self._client._request(
|
|
2625
|
+
"GET",
|
|
2626
|
+
"/v1/sessions/:sid/voice/live/:vid/media",
|
|
2627
|
+
path={"sid": sid, "vid": vid},
|
|
2628
|
+
query=query,
|
|
2629
|
+
timeout=timeout,
|
|
2630
|
+
)
|
|
2631
|
+
return response
|
|
2632
|
+
|
|
2633
|
+
def get_voice_job(
|
|
2634
|
+
self, job_id: str, *, query: Query | None = None, timeout: float | None = None
|
|
2635
|
+
) -> _types.VoiceJob:
|
|
2636
|
+
"""GET /v1/voice/jobs/:job-id — json response."""
|
|
2637
|
+
response = self._client._request(
|
|
2638
|
+
"GET",
|
|
2639
|
+
"/v1/voice/jobs/:job-id",
|
|
2640
|
+
path={"job-id": job_id},
|
|
2641
|
+
query=query,
|
|
2642
|
+
timeout=timeout,
|
|
2643
|
+
)
|
|
2644
|
+
return response.json()
|
|
2645
|
+
|
|
2646
|
+
def get_voice_model(
|
|
2647
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2648
|
+
) -> _types.VoiceModel:
|
|
2649
|
+
"""GET /v1/voice/model — json response."""
|
|
2650
|
+
response = self._client._request(
|
|
2651
|
+
"GET", "/v1/voice/model", path={}, query=query, timeout=timeout
|
|
2652
|
+
)
|
|
2653
|
+
return response.json()
|
|
2654
|
+
|
|
2655
|
+
def post_voice_model(
|
|
2656
|
+
self, *, query: Query | None = None, timeout: float | None = None
|
|
2657
|
+
) -> _types.VoiceModel:
|
|
2658
|
+
"""POST /v1/voice/model — json response."""
|
|
2659
|
+
response = self._client._request(
|
|
2660
|
+
"POST", "/v1/voice/model", path={}, query=query, timeout=timeout
|
|
2661
|
+
)
|
|
2662
|
+
return response.json()
|