@enclave-vm/client 2.19.0 → 2.19.2
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.
- package/README.md +168 -130
- package/client.d.ts +52 -6
- package/client.d.ts.map +1 -1
- package/esm/index.mjs +395 -177
- package/index.js +384 -174
- package/package.json +3 -3
- package/types.d.ts +23 -5
- package/types.d.ts.map +1 -1
package/README.md
CHANGED
|
@@ -6,16 +6,15 @@
|
|
|
6
6
|
|
|
7
7
|
> Browser and Node.js client SDK for the EnclaveJS streaming runtime
|
|
8
8
|
|
|
9
|
-
The @enclave-vm/client package
|
|
9
|
+
The @enclave-vm/client package is a client for an EnclaveJS broker, for browsers and Node.js applications. It sends a script to the broker over HTTP, reads the events of the session as they arrive, and gives you the result.
|
|
10
10
|
|
|
11
11
|
## Features
|
|
12
12
|
|
|
13
|
-
- **Cross-Platform**: Works in browsers and Node.js
|
|
14
|
-
- **Streaming Support**:
|
|
15
|
-
- **Auto-Reconnection**:
|
|
13
|
+
- **Cross-Platform**: Works in browsers and Node.js, on top of `fetch`
|
|
14
|
+
- **Streaming Support**: Session events are passed to your handlers as they arrive
|
|
15
|
+
- **Auto-Reconnection**: A lost connection is resumed after the last event received, so every event is delivered once and in order
|
|
16
|
+
- **Cancellation**: Stop a session with its handle, by its id, or with an `AbortSignal`
|
|
16
17
|
- **Type-Safe**: Full TypeScript support
|
|
17
|
-
- **Event-Based**: Rich event system for monitoring execution
|
|
18
|
-
- **Encryption Ready**: Built-in support for encrypted channels
|
|
19
18
|
|
|
20
19
|
## Installation
|
|
21
20
|
|
|
@@ -34,90 +33,82 @@ import { EnclaveClient } from '@enclave-vm/client';
|
|
|
34
33
|
|
|
35
34
|
// Create client
|
|
36
35
|
const client = new EnclaveClient({
|
|
37
|
-
|
|
36
|
+
baseUrl: 'https://api.example.com',
|
|
38
37
|
});
|
|
39
38
|
|
|
40
|
-
//
|
|
41
|
-
await client.connect();
|
|
42
|
-
|
|
39
|
+
// Execute code and wait for the result
|
|
43
40
|
const result = await client.execute(`
|
|
44
41
|
const user = await callTool('getUser', { id: 123 });
|
|
45
42
|
return { name: user.name };
|
|
46
43
|
`);
|
|
47
44
|
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
45
|
+
if (result.success) {
|
|
46
|
+
console.log(result.value); // what the script returned
|
|
47
|
+
} else {
|
|
48
|
+
console.error(result.error?.code, result.error?.message);
|
|
49
|
+
}
|
|
52
50
|
```
|
|
53
51
|
|
|
52
|
+
Tools run on the broker. The client is told about tool calls (`onToolCall`, `onToolResultApplied`), but it executes nothing and has no API to register tools.
|
|
53
|
+
|
|
54
54
|
## Event Handling
|
|
55
55
|
|
|
56
|
-
|
|
56
|
+
Pass handlers with the options of `execute()` or `executeStream()`:
|
|
57
57
|
|
|
58
58
|
```typescript
|
|
59
59
|
import { EnclaveClient } from '@enclave-vm/client';
|
|
60
60
|
|
|
61
|
-
const client = new EnclaveClient({
|
|
62
|
-
|
|
63
|
-
client.on('connected', () => {
|
|
64
|
-
console.log('Connected to runtime');
|
|
65
|
-
});
|
|
66
|
-
|
|
67
|
-
client.on('disconnected', (reason) => {
|
|
68
|
-
console.log('Disconnected:', reason);
|
|
69
|
-
});
|
|
61
|
+
const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
|
|
70
62
|
|
|
71
|
-
client.
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
}
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
63
|
+
const result = await client.execute(code, {
|
|
64
|
+
onSessionInit: (event) => {
|
|
65
|
+
console.log('Session started:', event.sessionId);
|
|
66
|
+
},
|
|
67
|
+
onStdout: (chunk) => {
|
|
68
|
+
process.stdout.write(chunk);
|
|
69
|
+
},
|
|
70
|
+
onLog: (level, message, data) => {
|
|
71
|
+
console.log(`[${level}]`, message, data);
|
|
72
|
+
},
|
|
73
|
+
onToolCall: (callId, toolName, args) => {
|
|
74
|
+
console.log(`Tool called: ${toolName}`, args);
|
|
75
|
+
},
|
|
76
|
+
onToolResultApplied: (callId) => {
|
|
77
|
+
console.log(`Tool result applied: ${callId}`);
|
|
78
|
+
},
|
|
79
|
+
onError: (errorCode, message) => {
|
|
80
|
+
console.error(`${errorCode}: ${message}`);
|
|
81
|
+
},
|
|
85
82
|
});
|
|
86
83
|
```
|
|
87
84
|
|
|
85
|
+
The handlers are `onEvent` (every event), `onSessionInit`, `onStdout`, `onLog`, `onToolCall`, `onToolResultApplied`, `onHeartbeat`, `onError`, `onPartialResult`, `onToolProgress`, `onDeadlineExceeded` and `onCatalogChanged`. The end of the session has no handler of its own: the result comes from the promise of `execute()`, or from `wait()` on the handle.
|
|
86
|
+
|
|
88
87
|
## Streaming Execution
|
|
89
88
|
|
|
90
|
-
|
|
89
|
+
`executeStream()` returns a handle for the running session at once:
|
|
91
90
|
|
|
92
91
|
```typescript
|
|
93
92
|
import { EnclaveClient } from '@enclave-vm/client';
|
|
94
93
|
|
|
95
|
-
const client = new EnclaveClient({
|
|
96
|
-
await client.connect();
|
|
94
|
+
const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
|
|
97
95
|
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
for (const id of [1, 2, 3]) {
|
|
102
|
-
const user = await callTool('getUser', { id });
|
|
103
|
-
yield user;
|
|
104
|
-
}
|
|
105
|
-
return 'done';
|
|
106
|
-
`,
|
|
107
|
-
{
|
|
108
|
-
onYield: (value) => {
|
|
109
|
-
console.log('Yielded:', value);
|
|
110
|
-
},
|
|
111
|
-
onComplete: (result) => {
|
|
112
|
-
console.log('Completed:', result);
|
|
113
|
-
},
|
|
114
|
-
onError: (error) => {
|
|
115
|
-
console.error('Error:', error);
|
|
116
|
-
},
|
|
96
|
+
const session = client.executeStream(code, {
|
|
97
|
+
onStdout: (chunk) => {
|
|
98
|
+
process.stdout.write(chunk);
|
|
117
99
|
},
|
|
118
|
-
);
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
console.log('Session ID:', session.sessionId);
|
|
103
|
+
console.log('Active:', session.isActive());
|
|
104
|
+
console.log('Events so far:', session.getEvents().length);
|
|
105
|
+
|
|
106
|
+
// Wait for the result
|
|
107
|
+
const result = await session.wait();
|
|
119
108
|
```
|
|
120
109
|
|
|
110
|
+
`await client.execute(code, options)` is the same as `await client.executeStream(code, options).wait()`.
|
|
111
|
+
|
|
121
112
|
## Configuration Options
|
|
122
113
|
|
|
123
114
|
```typescript
|
|
@@ -125,118 +116,165 @@ import { EnclaveClient } from '@enclave-vm/client';
|
|
|
125
116
|
|
|
126
117
|
const client = new EnclaveClient({
|
|
127
118
|
// Connection
|
|
128
|
-
|
|
129
|
-
protocols: ['enclavejs-v1'],
|
|
130
|
-
|
|
131
|
-
// Authentication
|
|
132
|
-
auth: {
|
|
133
|
-
token: 'your-api-token',
|
|
134
|
-
// or
|
|
135
|
-
apiKey: 'your-api-key',
|
|
136
|
-
},
|
|
119
|
+
baseUrl: 'https://api.example.com',
|
|
137
120
|
|
|
138
|
-
//
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
maxAttempts: 5,
|
|
142
|
-
initialDelay: 1000,
|
|
143
|
-
maxDelay: 30000,
|
|
121
|
+
// Headers sent with every request (for example credentials)
|
|
122
|
+
headers: {
|
|
123
|
+
Authorization: 'Bearer your-api-token',
|
|
144
124
|
},
|
|
145
125
|
|
|
146
|
-
//
|
|
147
|
-
|
|
148
|
-
enabled: true,
|
|
149
|
-
// Key exchange happens automatically
|
|
150
|
-
},
|
|
126
|
+
// Waiting for the server
|
|
127
|
+
timeout: 60000,
|
|
151
128
|
|
|
152
|
-
//
|
|
153
|
-
|
|
154
|
-
|
|
129
|
+
// Reconnection
|
|
130
|
+
autoReconnect: true,
|
|
131
|
+
maxReconnectAttempts: 3,
|
|
132
|
+
reconnectDelay: 1000,
|
|
155
133
|
|
|
156
|
-
//
|
|
157
|
-
|
|
134
|
+
// Largest event accepted
|
|
135
|
+
maxEventLength: 8388608,
|
|
158
136
|
});
|
|
159
137
|
```
|
|
160
138
|
|
|
139
|
+
| Option | Default | Description |
|
|
140
|
+
| ---------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
141
|
+
| `baseUrl` | Required | Base URL of the broker |
|
|
142
|
+
| `headers` | none | Headers sent with every request |
|
|
143
|
+
| `timeout` | `60000` | How long the client waits for the server, in milliseconds: for the answer to a request, and for the next event on an open stream (there, never less than two heartbeat intervals). When it runs out the connection counts as lost. |
|
|
144
|
+
| `autoReconnect` | `true` | Reconnect when the connection is lost |
|
|
145
|
+
| `maxReconnectAttempts` | `3` | Reconnection attempts in a row before the session fails |
|
|
146
|
+
| `reconnectDelay` | `1000` | Base delay before a reconnection attempt, in milliseconds; it grows with each attempt in a row |
|
|
147
|
+
| `maxEventLength` | `8388608` | Largest event the client accepts, in characters (8 MiB). A longer event ends the session with `PARSE_ERROR`. |
|
|
148
|
+
| `fetch` | global `fetch` | Custom fetch implementation. Required where there is no global `fetch`. |
|
|
149
|
+
|
|
150
|
+
These are all the options. Any other option makes the constructor throw a `TypeError` that names it: the client has no `encryption`, `auth`, `serverUrl` or `reconnect` option. A value the client cannot use, such as a `timeout` of `0`, throws as well.
|
|
151
|
+
|
|
152
|
+
The client does not encrypt. Requests and events travel as plain JSON over HTTP and are protected only by the transport: use an `https:` base URL, and send credentials with `headers`.
|
|
153
|
+
|
|
161
154
|
## Session Management
|
|
162
155
|
|
|
156
|
+
Every execution is a session with an id that starts with `s_`. The client generates the id unless you pass one with the `sessionId` option; an id that does not start with `s_` is refused before a request is made.
|
|
157
|
+
|
|
163
158
|
```typescript
|
|
164
159
|
import { EnclaveClient } from '@enclave-vm/client';
|
|
165
160
|
|
|
166
|
-
const client = new EnclaveClient({
|
|
167
|
-
await client.connect();
|
|
161
|
+
const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
|
|
168
162
|
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
163
|
+
const session = client.executeStream(code, {
|
|
164
|
+
// Limits requested for the session
|
|
165
|
+
limits: {
|
|
166
|
+
sessionTtlMs: 60000,
|
|
167
|
+
maxToolCalls: 100,
|
|
168
|
+
},
|
|
174
169
|
});
|
|
175
170
|
|
|
176
|
-
console.log('Session ID:', session.
|
|
171
|
+
console.log('Session ID:', session.sessionId);
|
|
177
172
|
|
|
178
|
-
//
|
|
179
|
-
const
|
|
180
|
-
|
|
173
|
+
// Ask the broker about the session (null if it does not know the session)
|
|
174
|
+
const info = await client.getSession(session.sessionId);
|
|
175
|
+
console.log(info?.state, info?.stats.toolCallCount);
|
|
181
176
|
|
|
182
|
-
//
|
|
183
|
-
await
|
|
177
|
+
// Cancel the session
|
|
178
|
+
await session.cancel('User cancelled');
|
|
179
|
+
// or: await client.cancelSession(session.sessionId, 'User cancelled');
|
|
180
|
+
|
|
181
|
+
const result = await session.wait();
|
|
182
|
+
console.log(result.error?.code); // 'CANCELLED'
|
|
184
183
|
```
|
|
185
184
|
|
|
185
|
+
`cancel()`, `cancelSession()` and aborting the `signal` option all do the same: the session ends in the client as `CANCELLED`, and the broker is asked to end it with `DELETE {baseUrl}/sessions/:sessionId`. They do not reject. If the broker does not confirm the stop, `onError` is called with the code `CANCEL_FAILED`: the script may still be running.
|
|
186
|
+
|
|
186
187
|
## Error Handling
|
|
187
188
|
|
|
188
|
-
|
|
189
|
-
import { EnclaveClient, EnclaveError, TimeoutError, ValidationError } from '@enclave-vm/client';
|
|
189
|
+
A session that fails is not a rejected promise. `execute()` and `wait()` resolve with `success: false` and an `error`:
|
|
190
190
|
|
|
191
|
-
|
|
191
|
+
```typescript
|
|
192
|
+
import { EnclaveClient, EnclaveClientError } from '@enclave-vm/client';
|
|
193
|
+
|
|
194
|
+
const client = new EnclaveClient({ baseUrl: 'https://api.example.com' });
|
|
195
|
+
|
|
196
|
+
const result = await client.execute(code);
|
|
197
|
+
|
|
198
|
+
if (!result.success) {
|
|
199
|
+
switch (result.error?.code) {
|
|
200
|
+
case 'CANCELLED':
|
|
201
|
+
console.error('Execution was cancelled');
|
|
202
|
+
break;
|
|
203
|
+
case 'TIMEOUT':
|
|
204
|
+
console.error('The broker did not answer in time');
|
|
205
|
+
break;
|
|
206
|
+
case 'NETWORK_ERROR':
|
|
207
|
+
case 'RECONNECT_FAILED':
|
|
208
|
+
console.error('Connection lost:', result.error?.message);
|
|
209
|
+
break;
|
|
210
|
+
default:
|
|
211
|
+
console.error('Execution failed:', result.error?.code, result.error?.message);
|
|
212
|
+
}
|
|
213
|
+
}
|
|
192
214
|
|
|
215
|
+
// getSession() is the one method that rejects, with an EnclaveClientError
|
|
193
216
|
try {
|
|
194
|
-
await client.
|
|
195
|
-
|
|
217
|
+
const info = await client.getSession(result.sessionId);
|
|
218
|
+
console.log(info?.state);
|
|
196
219
|
} catch (error) {
|
|
197
|
-
if (error instanceof
|
|
198
|
-
console.error('
|
|
199
|
-
} else if (error instanceof TimeoutError) {
|
|
200
|
-
console.error('Execution timed out');
|
|
201
|
-
} else if (error instanceof EnclaveError) {
|
|
202
|
-
console.error('Enclave error:', error.code, error.message);
|
|
220
|
+
if (error instanceof EnclaveClientError) {
|
|
221
|
+
console.error('Enclave client error:', error.code, error.message);
|
|
203
222
|
} else {
|
|
204
223
|
throw error;
|
|
205
224
|
}
|
|
206
225
|
}
|
|
207
226
|
```
|
|
208
227
|
|
|
228
|
+
`error.code` is one of the client's codes, or the code that the broker sent with the end of the session:
|
|
229
|
+
|
|
230
|
+
| Code | Meaning |
|
|
231
|
+
| ------------------ | ------------------------------------------------------------------------------------------------------------------ |
|
|
232
|
+
| `CANCELLED` | The session was cancelled with `cancel()`, `cancelSession()` or the `signal` |
|
|
233
|
+
| `TIMEOUT` | The broker did not answer, or sent no event, within the time the client waits |
|
|
234
|
+
| `NETWORK_ERROR` | A request failed, or the stream ended before the session was complete |
|
|
235
|
+
| `PARSE_ERROR` | The answer cannot be read: an event longer than `maxEventLength`, an encrypted event, or a response without a body |
|
|
236
|
+
| `SESSION_ERROR` | The broker refused to start the session, the session id is not valid, or the id is already running on this client |
|
|
237
|
+
| `RECONNECT_FAILED` | The broker refused a reconnection |
|
|
238
|
+
|
|
239
|
+
When the connection is lost and `autoReconnect` is on, the client reconnects first. If the attempts are used up, the session fails with the code of the last failure.
|
|
240
|
+
|
|
209
241
|
## Browser Usage
|
|
210
242
|
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
243
|
+
In the browser the client uses the global `fetch`:
|
|
244
|
+
|
|
245
|
+
```typescript
|
|
246
|
+
import { EnclaveClient } from '@enclave-vm/client';
|
|
214
247
|
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
248
|
+
const client = new EnclaveClient({
|
|
249
|
+
baseUrl: 'https://api.example.com',
|
|
250
|
+
});
|
|
218
251
|
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
252
|
+
async function runCode() {
|
|
253
|
+
const result = await client.execute(
|
|
254
|
+
`
|
|
222
255
|
const data = await callTool('fetchData', { url: '/api/users' });
|
|
223
256
|
return data;
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
257
|
+
`,
|
|
258
|
+
{
|
|
259
|
+
onStdout: (chunk) => {
|
|
260
|
+
document.body.append(chunk);
|
|
261
|
+
},
|
|
262
|
+
},
|
|
263
|
+
);
|
|
264
|
+
console.log(result);
|
|
265
|
+
}
|
|
227
266
|
|
|
228
|
-
|
|
229
|
-
</script>
|
|
267
|
+
runCode();
|
|
230
268
|
```
|
|
231
269
|
|
|
232
270
|
## Related Packages
|
|
233
271
|
|
|
234
|
-
| Package
|
|
235
|
-
|
|
|
236
|
-
| [@enclave-vm/types](../
|
|
237
|
-
| [@enclave-vm/stream](../
|
|
238
|
-
| [@enclave-vm/react](../
|
|
239
|
-
| [@enclave-vm/runtime](../
|
|
272
|
+
| Package | Description |
|
|
273
|
+
| --------------------------------- | ------------------------------------------------------- |
|
|
274
|
+
| [@enclave-vm/types](../types) | Type definitions and Zod schemas |
|
|
275
|
+
| [@enclave-vm/stream](../stream) | Streaming protocol implementation |
|
|
276
|
+
| [@enclave-vm/react](../react) | React hooks and components |
|
|
277
|
+
| [@enclave-vm/runtime](../runtime) | Runtime worker building blocks (not a runnable service) |
|
|
240
278
|
|
|
241
279
|
## License
|
|
242
280
|
|
package/client.d.ts
CHANGED
|
@@ -25,6 +25,9 @@ export declare class EnclaveClient {
|
|
|
25
25
|
private readonly activeSessions;
|
|
26
26
|
/**
|
|
27
27
|
* Create a new EnclaveClient instance.
|
|
28
|
+
*
|
|
29
|
+
* @throws TypeError when the configuration has an option this client does not implement
|
|
30
|
+
* (for example `encryption` or `auth`) or a value it cannot use
|
|
28
31
|
*/
|
|
29
32
|
constructor(config: EnclaveClientConfig);
|
|
30
33
|
/**
|
|
@@ -59,16 +62,52 @@ export declare class EnclaveClient {
|
|
|
59
62
|
getSession(sessionId: SessionId): Promise<SessionInfo | null>;
|
|
60
63
|
/**
|
|
61
64
|
* Cancel a running session.
|
|
65
|
+
*
|
|
66
|
+
* The session of this client ends as `CANCELLED`, and the server is asked to end the session
|
|
67
|
+
* (`DELETE /sessions/:sessionId`). When the server does not confirm that, the session's
|
|
68
|
+
* `onError` handler is called with the code `CANCEL_FAILED`: the script may still be running.
|
|
62
69
|
*/
|
|
63
70
|
cancelSession(sessionId: SessionId, reason?: string): Promise<void>;
|
|
71
|
+
/**
|
|
72
|
+
* End a session of this client as cancelled and ask the server to end it too.
|
|
73
|
+
* Never rejects.
|
|
74
|
+
*/
|
|
75
|
+
private stopSession;
|
|
64
76
|
/**
|
|
65
77
|
* Start a session and begin streaming events.
|
|
66
78
|
*/
|
|
67
79
|
private startSession;
|
|
80
|
+
/**
|
|
81
|
+
* Attempt to reconnect a session.
|
|
82
|
+
*/
|
|
83
|
+
private reconnectSession;
|
|
84
|
+
/**
|
|
85
|
+
* Open a connection for a session and follow its stream until the session ends or the
|
|
86
|
+
* connection is lost. A session has one connection at a time: the previous one is closed
|
|
87
|
+
* first, and nothing that still arrives on it is delivered.
|
|
88
|
+
*/
|
|
89
|
+
private runConnection;
|
|
68
90
|
/**
|
|
69
91
|
* Stream and parse the NDJSON response.
|
|
70
92
|
*/
|
|
71
93
|
private streamResponse;
|
|
94
|
+
/**
|
|
95
|
+
* (Re)start the timer of a connection. When it runs out the connection counts as lost.
|
|
96
|
+
*/
|
|
97
|
+
private watch;
|
|
98
|
+
/**
|
|
99
|
+
* Whether a connection is the one its session is using.
|
|
100
|
+
*/
|
|
101
|
+
private isCurrent;
|
|
102
|
+
/**
|
|
103
|
+
* Close the connection of a session, if it has one.
|
|
104
|
+
*/
|
|
105
|
+
private closeConnection;
|
|
106
|
+
/**
|
|
107
|
+
* A connection failed, ended early or went silent: reconnect if that is allowed, otherwise
|
|
108
|
+
* the session fails. A connection that is no longer the session's own is ignored.
|
|
109
|
+
*/
|
|
110
|
+
private connectionLost;
|
|
72
111
|
/**
|
|
73
112
|
* Handle a received stream event.
|
|
74
113
|
*/
|
|
@@ -78,17 +117,24 @@ export declare class EnclaveClient {
|
|
|
78
117
|
*/
|
|
79
118
|
private handleFinalEvent;
|
|
80
119
|
/**
|
|
81
|
-
*
|
|
120
|
+
* End a session with an error.
|
|
82
121
|
*/
|
|
83
|
-
private
|
|
122
|
+
private failSession;
|
|
84
123
|
/**
|
|
85
|
-
*
|
|
124
|
+
* End a session that was never requested from the server.
|
|
86
125
|
*/
|
|
87
|
-
private
|
|
126
|
+
private refuseSession;
|
|
88
127
|
/**
|
|
89
|
-
*
|
|
128
|
+
* Give a session its result and clean up. The first result is the only one.
|
|
90
129
|
*/
|
|
91
|
-
private
|
|
130
|
+
private endSession;
|
|
131
|
+
private cancelledResult;
|
|
132
|
+
private statsOf;
|
|
133
|
+
/**
|
|
134
|
+
* Run a request that is not a session stream, bounded by the configured timeout.
|
|
135
|
+
* The promise settles at the deadline even when the request does not react to its signal.
|
|
136
|
+
*/
|
|
137
|
+
private withDeadline;
|
|
92
138
|
/**
|
|
93
139
|
* Build request headers.
|
|
94
140
|
*/
|
package/client.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAA0C,MAAM,mBAAmB,CAAC;
|
|
1
|
+
{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAA0C,MAAM,mBAAmB,CAAC;AA0B3F,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAC;AA+KpB;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IACF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuC;IAEtE;;;;;OAKG;gBACS,MAAM,EAAE,mBAAmB;IAIvC;;;;;;;;;;OAUG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAc,GAAG,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IAKxG;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,cAAc,GAAG,oBAAyB,GAAG,aAAa;IAuF/F;;OAEG;IACG,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAmCnE;;;;;;OAMG;IACG,aAAa,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASzE;;;OAGG;YACW,WAAW;IA0CzB;;OAEG;YACW,YAAY;IAsC1B;;OAEG;YACW,gBAAgB;IA0B9B;;;;OAIG;YACW,aAAa;IA0B3B;;OAEG;YACW,cAAc;IA2B5B;;OAEG;IACH,OAAO,CAAC,KAAK;IAUb;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;;OAGG;IACH,OAAO,CAAC,cAAc;IA0BtB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmEnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,OAAO;IAQf;;;OAGG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,YAAY;CAKrB"}
|