@h-ai/ai 0.1.0-alpha.67 → 0.1.0-alpha.69

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.
@@ -1,578 +0,0 @@
1
- import { HaiAIError } from './chunk-JC7QBT3C.js';
2
-
3
- // src/client/ai-a2a-client.ts
4
- var A2A_PATH = {
5
- agentCard: "/a2a/agent-card",
6
- messages: "/a2a/messages",
7
- callRemote: "/a2a/call"
8
- };
9
- function createA2AClient(api) {
10
- return {
11
- async getAgentCard() {
12
- const result = await api.post(A2A_PATH.agentCard);
13
- if (!result.success) {
14
- throw new Error(`A2A get agent card failed: ${result.error.message}`);
15
- }
16
- return result.data;
17
- },
18
- async listMessages(filter) {
19
- const result = await api.post(A2A_PATH.messages, filter ?? {});
20
- if (!result.success) {
21
- throw new Error(`A2A list messages failed: ${result.error.message}`);
22
- }
23
- return result.data;
24
- },
25
- async callRemoteAgent(remoteUrl, message, options) {
26
- const result = await api.post(A2A_PATH.callRemote, {
27
- remoteUrl,
28
- message,
29
- ...options
30
- });
31
- if (!result.success) {
32
- throw new Error(`A2A remote call failed: ${result.error.message}`);
33
- }
34
- return result.data;
35
- }
36
- };
37
- }
38
-
39
- // src/client/ai-audio-client.ts
40
- function audioClientError(code, message) {
41
- const error = new Error(message);
42
- error.code = code;
43
- return error;
44
- }
45
- function openBrowserWs(url, signal) {
46
- return new Promise((resolve, reject) => {
47
- const ws = new WebSocket(url);
48
- ws.binaryType = "arraybuffer";
49
- const queue = [];
50
- let waiting = null;
51
- let closed = false;
52
- let opened = false;
53
- let aborted = false;
54
- let failure = null;
55
- function settleClosed() {
56
- if (closed)
57
- return;
58
- closed = true;
59
- signal?.removeEventListener("abort", onAbort);
60
- if (waiting) {
61
- const w = waiting;
62
- waiting = null;
63
- w({ value: void 0, done: true });
64
- }
65
- }
66
- function onAbort() {
67
- aborted = true;
68
- if (!opened) {
69
- settleClosed();
70
- reject(audioClientError(HaiAIError.AUDIO_CANCELLED.code, "Audio operation cancelled"));
71
- }
72
- ws.close();
73
- }
74
- function terminalError() {
75
- if (aborted)
76
- return audioClientError(HaiAIError.AUDIO_CANCELLED.code, "Audio operation cancelled");
77
- if (failure)
78
- return failure;
79
- return audioClientError(HaiAIError.AUDIO_CONNECTION_FAILED.code, "Audio WebSocket closed before completion");
80
- }
81
- function push(message) {
82
- if (waiting) {
83
- const w = waiting;
84
- waiting = null;
85
- w({ value: message, done: false });
86
- } else {
87
- queue.push(message);
88
- }
89
- }
90
- ws.onmessage = (event) => {
91
- if (typeof event.data === "string")
92
- push({ isBinary: false, text: event.data });
93
- else
94
- push({ isBinary: true, binary: new Uint8Array(event.data) });
95
- };
96
- ws.onerror = () => {
97
- failure = audioClientError(HaiAIError.AUDIO_CONNECTION_FAILED.code, "Audio WebSocket connection failed");
98
- if (!opened) {
99
- settleClosed();
100
- reject(failure);
101
- }
102
- };
103
- ws.onclose = () => settleClosed();
104
- if (signal) {
105
- if (signal.aborted)
106
- onAbort();
107
- else
108
- signal.addEventListener("abort", onAbort, { once: true });
109
- }
110
- ws.onopen = () => {
111
- opened = true;
112
- resolve({
113
- // DOM WebSocket.send 的 BufferSource 泛型限定为 ArrayBuffer,Uint8Array 需显式收窄
114
- send: (data) => ws.send(data),
115
- async *messages() {
116
- while (true) {
117
- if (queue.length > 0) {
118
- yield queue.shift();
119
- continue;
120
- }
121
- if (closed)
122
- throw terminalError();
123
- const next = await new Promise((res) => {
124
- waiting = res;
125
- });
126
- if (next.done)
127
- throw terminalError();
128
- yield next.value;
129
- }
130
- },
131
- close: () => ws.close()
132
- });
133
- };
134
- });
135
- }
136
- function createAudioClient(config) {
137
- async function buildUrl(request) {
138
- const ticket = await config.getTicket(request);
139
- if (!ticket)
140
- throw new Error("Audio WebSocket ticket is required");
141
- const separator = config.url.includes("?") ? "&" : "?";
142
- return `${config.url}${separator}ticket=${encodeURIComponent(ticket)}`;
143
- }
144
- function startMessage(operation, extra) {
145
- return JSON.stringify({ type: "start", operation, ...extra });
146
- }
147
- async function* transcribeStream(request) {
148
- const conn = await openBrowserWs(await buildUrl({ operation: "transcribe", model: request.model }), request.signal);
149
- try {
150
- const format = request.audio.format;
151
- const sampleRate = request.audio.sampleRate;
152
- conn.send(startMessage("transcribe", { stream: true, model: request.model, language: request.language, contextHints: request.contextHints, format, sampleRate, channels: request.audio.channels }));
153
- const sendAudio = (async () => {
154
- if ("chunks" in request.audio) {
155
- for await (const part of request.audio.chunks)
156
- conn.send(part);
157
- } else {
158
- conn.send(request.audio.data);
159
- }
160
- conn.send(JSON.stringify({ type: "done" }));
161
- })();
162
- let sendError;
163
- sendAudio.catch((e) => {
164
- sendError = e;
165
- });
166
- for await (const message of conn.messages()) {
167
- if (message.isBinary || !message.text)
168
- continue;
169
- const event = JSON.parse(message.text);
170
- if (event.type === "transcript")
171
- yield { type: "transcript", text: event.text, final: event.final };
172
- else if (event.type === "speech_started")
173
- yield { type: "speech_started" };
174
- else if (event.type === "speech_stopped")
175
- yield { type: "speech_stopped" };
176
- else if (event.type === "error")
177
- throw audioClientError(event.code, event.message);
178
- else if (event.type === "end")
179
- break;
180
- }
181
- if (sendError)
182
- throw sendError;
183
- } finally {
184
- conn.close();
185
- }
186
- }
187
- async function transcribe(request) {
188
- const conn = await openBrowserWs(await buildUrl({ operation: "transcribe", model: request.model }), request.signal);
189
- try {
190
- conn.send(startMessage("transcribe", { stream: false, model: request.model, language: request.language, contextHints: request.contextHints, format: request.audio.format, sampleRate: request.audio.sampleRate, channels: request.audio.channels }));
191
- conn.send(request.audio.data);
192
- conn.send(JSON.stringify({ type: "done" }));
193
- let text = "";
194
- for await (const message of conn.messages()) {
195
- if (message.isBinary || !message.text)
196
- continue;
197
- const event = JSON.parse(message.text);
198
- if (event.type === "transcript")
199
- text = event.text;
200
- else if (event.type === "error")
201
- throw audioClientError(event.code, event.message);
202
- else if (event.type === "end")
203
- break;
204
- }
205
- return { text };
206
- } finally {
207
- conn.close();
208
- }
209
- }
210
- async function* synthesizeStream(request) {
211
- const conn = await openBrowserWs(await buildUrl({ operation: "synthesize", model: request.model }), request.signal);
212
- try {
213
- conn.send(startMessage("synthesize", { model: request.model, voice: request.voice, instruction: request.instruction, format: request.format, sampleRate: request.sampleRate }));
214
- const sendText = (async () => {
215
- const segments = isSynthesisTextSegment(request.text) ? singleSegment(request.text) : request.text;
216
- for await (const segment of segments)
217
- conn.send(JSON.stringify({ type: "text", segmentId: segment.id, text: segment.text }));
218
- conn.send(JSON.stringify({ type: "done" }));
219
- })();
220
- let sendError;
221
- sendText.catch((e) => {
222
- sendError = e;
223
- });
224
- let activeSegmentId;
225
- for await (const message of conn.messages()) {
226
- if (message.isBinary && message.binary) {
227
- if (!activeSegmentId)
228
- throw new Error("Audio frame received outside a synthesis segment");
229
- yield { type: "audio", segmentId: activeSegmentId, data: message.binary };
230
- continue;
231
- }
232
- if (!message.text)
233
- continue;
234
- const event = JSON.parse(message.text);
235
- if (event.type === "segment_started") {
236
- if (activeSegmentId)
237
- throw new Error("Synthesis segment started before the previous segment completed");
238
- activeSegmentId = event.segmentId;
239
- yield event;
240
- } else if (event.type === "segment_done") {
241
- if (activeSegmentId !== event.segmentId)
242
- throw new Error("Synthesis segment completion does not match the active segment");
243
- yield event;
244
- activeSegmentId = void 0;
245
- } else if (event.type === "error") {
246
- throw audioClientError(event.code, event.message);
247
- } else if (event.type === "end") {
248
- if (activeSegmentId)
249
- throw audioClientError(HaiAIError.AUDIO_PROTOCOL_ERROR.code, "Synthesis ended before the active segment completed");
250
- break;
251
- }
252
- }
253
- if (sendError)
254
- throw sendError;
255
- } finally {
256
- conn.close();
257
- }
258
- }
259
- async function synthesize(request) {
260
- const chunks = [];
261
- let meta;
262
- for await (const event of synthesizeStream({ ...request, text: { id: "synthesis", text: request.text } })) {
263
- if (event.type === "segment_started")
264
- meta = { format: event.format, sampleRate: event.sampleRate, channels: event.channels };
265
- else if (event.type === "audio")
266
- chunks.push(event.data);
267
- }
268
- if (!meta)
269
- throw audioClientError(HaiAIError.AUDIO_PROTOCOL_ERROR.code, "Synthesis completed without segment metadata");
270
- const total = chunks.reduce((sum, c) => sum + c.length, 0);
271
- const data = new Uint8Array(total);
272
- let offset = 0;
273
- for (const chunk of chunks) {
274
- data.set(chunk, offset);
275
- offset += chunk.length;
276
- }
277
- return { data, format: meta.format, sampleRate: meta.sampleRate, channels: meta.channels ?? 1 };
278
- }
279
- return { transcribe, transcribeStream, synthesize, synthesizeStream };
280
- }
281
- function isSynthesisTextSegment(value) {
282
- return typeof value === "object" && value !== null && "id" in value && "text" in value;
283
- }
284
- async function* singleSegment(segment) {
285
- yield segment;
286
- }
287
- function createUnconfiguredAudioClient() {
288
- const message = "Audio client not configured. Provide `audio` in createAIClient() config.";
289
- return {
290
- transcribe: () => Promise.reject(new Error(message)),
291
- async *transcribeStream() {
292
- throw new Error(message);
293
- },
294
- synthesize: () => Promise.reject(new Error(message)),
295
- async *synthesizeStream() {
296
- throw new Error(message);
297
- }
298
- };
299
- }
300
-
301
- // src/client/ai-client.ts
302
- var AI_PATH = {
303
- // LLM
304
- chat: "/ai/chat",
305
- chatStream: "/ai/chat/stream",
306
- chatHistory: "/ai/chat/history",
307
- ask: "/ai/ask",
308
- askStream: "/ai/ask/stream",
309
- // Knowledge
310
- knowledgeRetrieve: "/ai/knowledge/retrieve",
311
- knowledgeAsk: "/ai/knowledge/ask",
312
- knowledgeIngest: "/ai/knowledge/ingest",
313
- knowledgeDocuments: "/ai/knowledge/documents",
314
- knowledgeRemoveDocument: "/ai/knowledge/documents/remove",
315
- // Memory
316
- memoryRecall: "/ai/memory/recall",
317
- memoryList: "/ai/memory/list",
318
- memoryAdd: "/ai/memory/add",
319
- memoryUpdate: "/ai/memory/update",
320
- memoryRemove: "/ai/memory/remove",
321
- // Session
322
- sessions: "/ai/sessions",
323
- sessionRename: "/ai/sessions/rename",
324
- sessionRemove: "/ai/sessions/remove",
325
- // RAG
326
- ragQuery: "/ai/rag/query",
327
- ragQueryStream: "/ai/rag/query/stream",
328
- // Reasoning
329
- reasoningRun: "/ai/reasoning/run",
330
- reasoningRunStream: "/ai/reasoning/run/stream",
331
- // Token
332
- tokenEstimate: "/ai/token/estimate"
333
- };
334
- function createAIClient(config) {
335
- const { api } = config;
336
- const audio = config.audio ? createAudioClient(config.audio) : createUnconfiguredAudioClient();
337
- return {
338
- async chat(req) {
339
- const result = await api.post(AI_PATH.chat, { ...req, stream: false });
340
- if (!result.success) {
341
- throw new Error(`AI chat request failed: ${result.error.message}`);
342
- }
343
- return result.data;
344
- },
345
- async *chatStream(req, options) {
346
- let content = "";
347
- for await (const data of api.stream(AI_PATH.chatStream, { ...req, stream: true })) {
348
- try {
349
- const chunk = JSON.parse(data);
350
- const delta = chunk.choices[0]?.delta?.content;
351
- if (delta) {
352
- content += delta;
353
- }
354
- const finishReason = chunk.choices[0]?.finish_reason;
355
- if (finishReason) {
356
- options?.onProgress?.({ content, done: true, finishReason });
357
- } else {
358
- options?.onProgress?.({ content, done: false });
359
- }
360
- yield chunk;
361
- } catch {
362
- }
363
- }
364
- },
365
- async sendMessage(message, systemPrompt) {
366
- const messages = [];
367
- if (systemPrompt) {
368
- messages.push({ role: "system", content: systemPrompt });
369
- }
370
- messages.push({ role: "user", content: message });
371
- const response = await this.chat({ messages });
372
- return response.choices[0]?.message?.content ?? "";
373
- },
374
- async sendMessageStream(message, options, systemPrompt) {
375
- const messages = [];
376
- if (systemPrompt) {
377
- messages.push({ role: "system", content: systemPrompt });
378
- }
379
- messages.push({ role: "user", content: message });
380
- let content = "";
381
- for await (const chunk of this.chatStream({ messages }, options)) {
382
- const delta = chunk.choices[0]?.delta?.content;
383
- if (delta) {
384
- content += delta;
385
- }
386
- }
387
- return content;
388
- },
389
- async recallMemories(query, options) {
390
- const result = await api.post(AI_PATH.memoryRecall, { query, ...options });
391
- if (!result.success) {
392
- throw new Error(`Memory recall failed: ${result.error.message}`);
393
- }
394
- return result.data.items;
395
- },
396
- async listMemories(options) {
397
- const result = await api.post(AI_PATH.memoryList, options ?? {});
398
- if (!result.success) {
399
- throw new Error(`Memory list failed: ${result.error.message}`);
400
- }
401
- return result.data;
402
- },
403
- async listSessions(objectId) {
404
- const result = await api.post(AI_PATH.sessions, { objectId });
405
- if (!result.success) {
406
- throw new Error(`Session list failed: ${result.error.message}`);
407
- }
408
- return result.data.items;
409
- },
410
- async chatHistory(objectId, sessionId, options) {
411
- const result = await api.post(AI_PATH.chatHistory, { objectId, sessionId, ...options });
412
- if (!result.success) {
413
- throw new Error(`Chat history failed: ${result.error.message}`);
414
- }
415
- return result.data.items;
416
- },
417
- // ─── LLM ask/askStream ───
418
- async ask(question, options) {
419
- const result = await api.post(AI_PATH.ask, { question, ...options });
420
- if (!result.success) {
421
- throw new Error(`AI ask failed: ${result.error.message}`);
422
- }
423
- return result.data.text;
424
- },
425
- async *askStream(question, options) {
426
- for await (const data of api.stream(AI_PATH.askStream, { question, ...options })) {
427
- yield data;
428
- }
429
- },
430
- // ─── Knowledge ───
431
- async knowledgeRetrieve(query, options) {
432
- const result = await api.post(AI_PATH.knowledgeRetrieve, { query, ...options });
433
- if (!result.success) {
434
- throw new Error(`Knowledge retrieve failed: ${result.error.message}`);
435
- }
436
- return result.data;
437
- },
438
- async knowledgeAsk(query, options) {
439
- const result = await api.post(AI_PATH.knowledgeAsk, { query, ...options });
440
- if (!result.success) {
441
- throw new Error(`Knowledge ask failed: ${result.error.message}`);
442
- }
443
- return result.data;
444
- },
445
- async knowledgeIngest(input) {
446
- const result = await api.post(AI_PATH.knowledgeIngest, input);
447
- if (!result.success) {
448
- throw new Error(`Knowledge ingest failed: ${result.error.message}`);
449
- }
450
- return result.data;
451
- },
452
- async knowledgeListDocuments(options) {
453
- const result = await api.post(AI_PATH.knowledgeDocuments, options ?? {});
454
- if (!result.success) {
455
- throw new Error(`Knowledge list documents failed: ${result.error.message}`);
456
- }
457
- return result.data.items;
458
- },
459
- async knowledgeRemoveDocument(documentId, options) {
460
- const result = await api.post(AI_PATH.knowledgeRemoveDocument, { documentId, ...options });
461
- if (!result.success) {
462
- throw new Error(`Knowledge remove document failed: ${result.error.message}`);
463
- }
464
- },
465
- // ─── Memory (extended) ───
466
- async addMemory(entry) {
467
- const result = await api.post(AI_PATH.memoryAdd, entry);
468
- if (!result.success) {
469
- throw new Error(`Memory add failed: ${result.error.message}`);
470
- }
471
- return result.data;
472
- },
473
- async updateMemory(memoryId, updates) {
474
- const result = await api.post(AI_PATH.memoryUpdate, { memoryId, ...updates });
475
- if (!result.success) {
476
- throw new Error(`Memory update failed: ${result.error.message}`);
477
- }
478
- return result.data;
479
- },
480
- async removeMemory(memoryId) {
481
- const result = await api.post(AI_PATH.memoryRemove, { memoryId });
482
- if (!result.success) {
483
- throw new Error(`Memory remove failed: ${result.error.message}`);
484
- }
485
- },
486
- // ─── Session (extended) ───
487
- async renameSession(sessionId, title) {
488
- const result = await api.post(AI_PATH.sessionRename, { sessionId, title });
489
- if (!result.success) {
490
- throw new Error(`Session rename failed: ${result.error.message}`);
491
- }
492
- },
493
- async removeSession(sessionId) {
494
- const result = await api.post(AI_PATH.sessionRemove, { sessionId });
495
- if (!result.success) {
496
- throw new Error(`Session remove failed: ${result.error.message}`);
497
- }
498
- },
499
- // ─── RAG ───
500
- async ragQuery(query, options) {
501
- const result = await api.post(AI_PATH.ragQuery, { query, ...options });
502
- if (!result.success) {
503
- throw new Error(`RAG query failed: ${result.error.message}`);
504
- }
505
- return result.data;
506
- },
507
- async *ragQueryStream(query, options) {
508
- for await (const data of api.stream(AI_PATH.ragQueryStream, { query, ...options })) {
509
- yield data;
510
- }
511
- },
512
- // ─── Reasoning ───
513
- async reasoningRun(query, options) {
514
- const result = await api.post(AI_PATH.reasoningRun, { query, ...options });
515
- if (!result.success) {
516
- throw new Error(`Reasoning run failed: ${result.error.message}`);
517
- }
518
- return result.data;
519
- },
520
- async *reasoningRunStream(query, options) {
521
- for await (const data of api.stream(AI_PATH.reasoningRunStream, { query, ...options })) {
522
- yield data;
523
- }
524
- },
525
- // ─── Token ───
526
- async estimateTokens(text) {
527
- const result = await api.post(AI_PATH.tokenEstimate, { text });
528
- if (!result.success) {
529
- throw new Error(`Token estimate failed: ${result.error.message}`);
530
- }
531
- return result.data;
532
- },
533
- // ─── Audio ───
534
- audio
535
- };
536
- }
537
- async function* parseSSE(response) {
538
- const reader = response.body?.getReader();
539
- if (!reader) {
540
- throw new Error("Response body is not readable");
541
- }
542
- const decoder = new TextDecoder();
543
- let buffer = "";
544
- try {
545
- while (true) {
546
- const { done, value } = await reader.read();
547
- if (done)
548
- break;
549
- buffer += decoder.decode(value, { stream: true });
550
- const lines = buffer.split("\n");
551
- buffer = lines.pop() ?? "";
552
- for (const line of lines) {
553
- if (line.startsWith("data: ")) {
554
- const data = line.slice(6);
555
- if (data !== "[DONE]") {
556
- yield data;
557
- }
558
- }
559
- }
560
- }
561
- } finally {
562
- reader.releaseLock();
563
- }
564
- }
565
- async function collectStreamContent(stream) {
566
- let content = "";
567
- for await (const chunk of stream) {
568
- const delta = chunk.choices[0]?.delta?.content;
569
- if (delta) {
570
- content += delta;
571
- }
572
- }
573
- return content;
574
- }
575
-
576
- export { collectStreamContent, createA2AClient, createAIClient, createAudioClient, createUnconfiguredAudioClient, parseSSE };
577
- //# sourceMappingURL=chunk-7SMQSE4S.js.map
578
- //# sourceMappingURL=chunk-7SMQSE4S.js.map