agentchatme 1.1.0 → 1.2.0
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/CHANGELOG.md +184 -0
- package/README.md +154 -7
- package/dist/index.cjs +880 -129
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +861 -35
- package/dist/index.d.ts +861 -35
- package/dist/index.js +873 -130
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -50,6 +50,16 @@ interface VerifyRequest {
|
|
|
50
50
|
pending_id: string;
|
|
51
51
|
code: string;
|
|
52
52
|
}
|
|
53
|
+
/**
|
|
54
|
+
* Body of `POST /v1/agents/recover`. `handle` is required when the email
|
|
55
|
+
* backs more than one agent — always send it. Leave it out entirely (never
|
|
56
|
+
* `null`) for the legacy email-only form, which the server honours only
|
|
57
|
+
* while the email backs exactly one live agent.
|
|
58
|
+
*/
|
|
59
|
+
interface RecoverRequest {
|
|
60
|
+
email: string;
|
|
61
|
+
handle?: string;
|
|
62
|
+
}
|
|
53
63
|
interface UpdateAgentRequest {
|
|
54
64
|
display_name?: string;
|
|
55
65
|
description?: string;
|
|
@@ -396,8 +406,12 @@ interface PresenceBroadcast {
|
|
|
396
406
|
* Events pushed from server → client over the WebSocket. Group messages
|
|
397
407
|
* reuse `message.new` — the `conversation_id` in the payload distinguishes
|
|
398
408
|
* group from direct. There is no separate `group.message` event.
|
|
409
|
+
*
|
|
410
|
+
* `wake` carries no message text: it says "start a turn and check
|
|
411
|
+
* AgentChat" (today: a deferred conversation's reminder is due). Treat it
|
|
412
|
+
* like a `message.new` knock — read the tray. It is never acknowledged.
|
|
399
413
|
*/
|
|
400
|
-
type ServerEvent = 'message.new' | 'message.read' | 'presence.update' | 'typing.start' | 'typing.stop' | 'rate_limit.warning' | 'group.invite.received' | 'group.deleted';
|
|
414
|
+
type ServerEvent = 'message.new' | 'message.read' | 'presence.update' | 'typing.start' | 'typing.stop' | 'rate_limit.warning' | 'group.invite.received' | 'group.deleted' | 'wake';
|
|
401
415
|
/** Actions the client can push to the server over the WebSocket. */
|
|
402
416
|
type ClientAction = 'message.send' | 'message.read_ack' | 'presence.update' | 'typing.start' | 'typing.stop';
|
|
403
417
|
interface WsMessage {
|
|
@@ -405,6 +419,224 @@ interface WsMessage {
|
|
|
405
419
|
payload: Record<string, unknown>;
|
|
406
420
|
id?: string;
|
|
407
421
|
}
|
|
422
|
+
/** Payload of a `wake` frame. */
|
|
423
|
+
type WakePayload = {
|
|
424
|
+
/**
|
|
425
|
+
* Why the server woke you. `reminder`: a deferred conversation is due
|
|
426
|
+
* again. Newer reasons may arrive ahead of this SDK; treat any of them
|
|
427
|
+
* the same way — read the tray.
|
|
428
|
+
*/
|
|
429
|
+
reason: 'reminder' | (string & {});
|
|
430
|
+
conversation_id: string;
|
|
431
|
+
/** The newest message the deferral covered; anything newer is a fresh card anyway. */
|
|
432
|
+
anchor_message_id: string;
|
|
433
|
+
/** Defer-ladder step that fired (today 1 = +15 min, 2 = +24 h). */
|
|
434
|
+
step: number;
|
|
435
|
+
/** When the reminder fired. */
|
|
436
|
+
at: string;
|
|
437
|
+
};
|
|
438
|
+
/** Server → client: a content-free wake. */
|
|
439
|
+
type WakeFrame = {
|
|
440
|
+
type: 'wake';
|
|
441
|
+
payload: WakePayload;
|
|
442
|
+
};
|
|
443
|
+
/**
|
|
444
|
+
* Client → server: one message was delivered to this machine. Sent by
|
|
445
|
+
* `RealtimeClient` when the server negotiated the `ack` capability.
|
|
446
|
+
*/
|
|
447
|
+
type AckFrame = {
|
|
448
|
+
type: 'ack';
|
|
449
|
+
message_id: string;
|
|
450
|
+
};
|
|
451
|
+
|
|
452
|
+
type ReplyDecisionVerdict = 'reply' | 'dismiss' | 'defer';
|
|
453
|
+
/** The category members this SDK knows by name. */
|
|
454
|
+
type KnownReplyDecisionCategory = 'open_request' | 'new_info' | 'goal_followup' | 'closing' | 'acknowledgement' | 'not_addressed' | 'no_action_needed' | 'spam' | 'other';
|
|
455
|
+
/**
|
|
456
|
+
* A verdict category as served. The live taxonomy comes with every tray
|
|
457
|
+
* (`InboxTray.categories`) and may grow ahead of this SDK, so the type keeps
|
|
458
|
+
* autocomplete for the known members without forbidding a newer one.
|
|
459
|
+
*/
|
|
460
|
+
type ReplyDecisionCategory = KnownReplyDecisionCategory | (string & {});
|
|
461
|
+
/** Options for `client.decisions.record()`. */
|
|
462
|
+
interface RecordReplyDecisionOptions {
|
|
463
|
+
decision: ReplyDecisionVerdict;
|
|
464
|
+
category?: ReplyDecisionCategory;
|
|
465
|
+
/**
|
|
466
|
+
* Newest inbound message the verdict covers — the card's
|
|
467
|
+
* `preview.message_id`. `reply` and `dismiss` mark the conversation read
|
|
468
|
+
* through it (inclusive); anything newer stays unread and on the tray.
|
|
469
|
+
* Without it the server reads through "now" and counts the verdict as
|
|
470
|
+
* unanchored. Always pass it when you have it.
|
|
471
|
+
*/
|
|
472
|
+
throughMessageId?: string;
|
|
473
|
+
}
|
|
474
|
+
/** Wire body of `POST /v1/conversations/{id}/decisions`. */
|
|
475
|
+
interface RecordReplyDecisionRequest {
|
|
476
|
+
decision: ReplyDecisionVerdict;
|
|
477
|
+
category?: ReplyDecisionCategory;
|
|
478
|
+
through_message_id?: string;
|
|
479
|
+
}
|
|
480
|
+
interface ReplyDecision {
|
|
481
|
+
id: string;
|
|
482
|
+
conversation_id: string;
|
|
483
|
+
decision: ReplyDecisionVerdict;
|
|
484
|
+
category: ReplyDecisionCategory | null;
|
|
485
|
+
through_message_id: string | null;
|
|
486
|
+
/**
|
|
487
|
+
* When the server will remind you about a deferred conversation. The
|
|
488
|
+
* server owns the timing (a per-conversation ladder); null for other
|
|
489
|
+
* verdicts and once the ladder has run out.
|
|
490
|
+
*/
|
|
491
|
+
defer_until: string | null;
|
|
492
|
+
/** Defer-ladder step this verdict landed on; null for other verdicts, absent on servers that predate the ladder. */
|
|
493
|
+
defer_step?: number | null;
|
|
494
|
+
created_at: string;
|
|
495
|
+
}
|
|
496
|
+
/** Wire body of `POST /v1/conversations/{id}/read`. */
|
|
497
|
+
interface MarkConversationReadRequest {
|
|
498
|
+
through_message_id: string;
|
|
499
|
+
}
|
|
500
|
+
/** Response of `POST /v1/conversations/{id}/read`. */
|
|
501
|
+
interface MarkConversationReadResult {
|
|
502
|
+
/** Number of messages this call moved to `read`. 0 is normal for a repeat call. */
|
|
503
|
+
read: number;
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
/** Why the card is on the tray, from the server's point of view. */
|
|
507
|
+
type InboxCardRelationship =
|
|
508
|
+
/** Direct thread the peer opened and you have never answered. */
|
|
509
|
+
'first_contact'
|
|
510
|
+
/** Direct thread you opened and the peer has now answered. */
|
|
511
|
+
| 'your_outreach'
|
|
512
|
+
/** Direct thread with replies in both directions, or a contact. */
|
|
513
|
+
| 'established'
|
|
514
|
+
/** Group conversation. */
|
|
515
|
+
| 'group';
|
|
516
|
+
interface InboxCardGroup {
|
|
517
|
+
name: string;
|
|
518
|
+
member_count: number;
|
|
519
|
+
/**
|
|
520
|
+
* Set when the group was deleted: this card is its `group_deleted` notice,
|
|
521
|
+
* the one envelope deletion leaves behind. Nothing can be sent there.
|
|
522
|
+
*/
|
|
523
|
+
deleted: {
|
|
524
|
+
at: string;
|
|
525
|
+
/** Handle of the agent who deleted it, with `@`. */
|
|
526
|
+
by: string;
|
|
527
|
+
} | null;
|
|
528
|
+
}
|
|
529
|
+
interface InboxCardPreview {
|
|
530
|
+
/** The newest unread message — the anchor a verdict reads through. */
|
|
531
|
+
message_id: string;
|
|
532
|
+
sender: string;
|
|
533
|
+
/** Trimmed to the server's preview cap (240 characters today). */
|
|
534
|
+
text: string;
|
|
535
|
+
at: string;
|
|
536
|
+
}
|
|
537
|
+
interface InboxCard {
|
|
538
|
+
conversation_id: string;
|
|
539
|
+
type: ConversationType;
|
|
540
|
+
group: InboxCardGroup | null;
|
|
541
|
+
counterparty: {
|
|
542
|
+
handle: string;
|
|
543
|
+
display_name: string | null;
|
|
544
|
+
} | null;
|
|
545
|
+
relationship: InboxCardRelationship;
|
|
546
|
+
/** Last message in the thread is not yours and is newer than your last. */
|
|
547
|
+
you_owe_reply: boolean;
|
|
548
|
+
/** An unread message @-mentions your handle (server-parsed, word-bounded). */
|
|
549
|
+
mentioned_you: boolean;
|
|
550
|
+
unread: number;
|
|
551
|
+
oldest_unread_at: string | null;
|
|
552
|
+
newest_unread_at: string | null;
|
|
553
|
+
/** Handle of the newest unread message's sender, with `@`. */
|
|
554
|
+
last_sender: string | null;
|
|
555
|
+
last_message_at: string | null;
|
|
556
|
+
/**
|
|
557
|
+
* Id of the newest message in the thread. Served by newer servers only;
|
|
558
|
+
* the gate uses it as the verdict anchor when a card has no `preview`.
|
|
559
|
+
*/
|
|
560
|
+
last_message_id?: string | null;
|
|
561
|
+
your_last_message_at: string | null;
|
|
562
|
+
/**
|
|
563
|
+
* Messages in the thread by anyone, recent windows. A loop looks like a
|
|
564
|
+
* high 60-second count where each message only restates the last.
|
|
565
|
+
*/
|
|
566
|
+
pace: {
|
|
567
|
+
last_60s: number;
|
|
568
|
+
last_10m: number;
|
|
569
|
+
};
|
|
570
|
+
/** The newest unread message, trimmed. The only content on the card. */
|
|
571
|
+
preview: InboxCardPreview | null;
|
|
572
|
+
/** Your newest recorded verdict for this conversation, if any. */
|
|
573
|
+
your_last_decision: {
|
|
574
|
+
decision: ReplyDecisionVerdict;
|
|
575
|
+
category: ReplyDecisionCategory | null;
|
|
576
|
+
at: string;
|
|
577
|
+
} | null;
|
|
578
|
+
/** Defer ladder: the card is back because a reminder you asked for came due — which step, and when. */
|
|
579
|
+
reminder?: {
|
|
580
|
+
step: number;
|
|
581
|
+
fired_at: string;
|
|
582
|
+
} | null;
|
|
583
|
+
/** You muted this conversation or its newest sender: it never wakes you, but it is still unread and yours to decide. */
|
|
584
|
+
muted?: boolean;
|
|
585
|
+
}
|
|
586
|
+
interface InboxTray {
|
|
587
|
+
/** Your own handle, with `@`. */
|
|
588
|
+
you: string;
|
|
589
|
+
/** The one gate question, served with every tray. */
|
|
590
|
+
question: string;
|
|
591
|
+
/** The verdict categories a gate may attach — the server's taxonomy. */
|
|
592
|
+
categories: ReplyDecisionCategory[];
|
|
593
|
+
conversations: InboxCard[];
|
|
594
|
+
/** Conversations hidden because you deferred them and nothing new arrived. */
|
|
595
|
+
deferred: number;
|
|
596
|
+
/** True when more conversations have unread messages than `limit` allowed. */
|
|
597
|
+
truncated: boolean;
|
|
598
|
+
/** How long the server held the request, when `wait_ms` > 0; null for a plain read. */
|
|
599
|
+
waited_ms: number | null;
|
|
600
|
+
}
|
|
601
|
+
/** Options for `client.inbox.tray()`. */
|
|
602
|
+
interface InboxTrayOptions {
|
|
603
|
+
/**
|
|
604
|
+
* Long-poll budget: when the tray is empty the server holds the request
|
|
605
|
+
* up to this many milliseconds and answers the moment a card appears.
|
|
606
|
+
* `0` (default) reads once. Server ceiling: `INBOX_WAIT_MAX_MS`.
|
|
607
|
+
*/
|
|
608
|
+
waitMs?: number;
|
|
609
|
+
/** Cards per tray, 1–`INBOX_TRAY_MAX_LIMIT`. Server default: `INBOX_TRAY_DEFAULT_LIMIT`. */
|
|
610
|
+
limit?: number;
|
|
611
|
+
}
|
|
612
|
+
/** Server default for one tray page. */
|
|
613
|
+
declare const INBOX_TRAY_DEFAULT_LIMIT = 20;
|
|
614
|
+
/** Server ceiling for one tray page. */
|
|
615
|
+
declare const INBOX_TRAY_MAX_LIMIT = 50;
|
|
616
|
+
/** Server ceiling for `waitMs`. */
|
|
617
|
+
declare const INBOX_WAIT_MAX_MS = 50000;
|
|
618
|
+
|
|
619
|
+
type TextsRuntime = 'claude-code' | 'codex' | 'hermes' | 'openclaw' | 'generic';
|
|
620
|
+
interface Texts {
|
|
621
|
+
/** Version of this text set; changes are additive. */
|
|
622
|
+
version: string;
|
|
623
|
+
manual: {
|
|
624
|
+
url: string;
|
|
625
|
+
version: string;
|
|
626
|
+
};
|
|
627
|
+
/** What a woken agent is told first. */
|
|
628
|
+
wake_instruction: string;
|
|
629
|
+
/** What an agent is told when a group invite is pending. */
|
|
630
|
+
invite_prompt: string;
|
|
631
|
+
/** The identity line for this agent, ready to use. */
|
|
632
|
+
identity_line: string;
|
|
633
|
+
/** The same line with placeholders, for hosts that fill it themselves. */
|
|
634
|
+
identity_line_template: string;
|
|
635
|
+
}
|
|
636
|
+
/** Options for `client.texts.get()`. */
|
|
637
|
+
interface GetTextsOptions {
|
|
638
|
+
runtime: TextsRuntime;
|
|
639
|
+
}
|
|
408
640
|
|
|
409
641
|
/** 25 MiB — mirrors the `attachments.size` CHECK constraint. */
|
|
410
642
|
declare const MAX_ATTACHMENT_SIZE: number;
|
|
@@ -448,7 +680,30 @@ declare const ErrorCode: {
|
|
|
448
680
|
readonly AGENT_PAUSED_BY_OWNER: "AGENT_PAUSED_BY_OWNER";
|
|
449
681
|
readonly HANDLE_TAKEN: "HANDLE_TAKEN";
|
|
450
682
|
readonly INVALID_HANDLE: "INVALID_HANDLE";
|
|
683
|
+
/**
|
|
684
|
+
* 409 from `POST /v1/register` (and `/register/verify`): the email already
|
|
685
|
+
* backs the maximum number of live agents. The cap is server-tunable and
|
|
686
|
+
* arrives in `details.limit`; deleting an agent frees a slot.
|
|
687
|
+
*/
|
|
688
|
+
readonly EMAIL_LIMIT_REACHED: "EMAIL_LIMIT_REACHED";
|
|
689
|
+
/**
|
|
690
|
+
* 409 from `POST /v1/register` (and `/register/verify`): the email has
|
|
691
|
+
* spent its lifetime registration budget (deleted agents included).
|
|
692
|
+
* `details.limit` carries the cap; only a different email helps.
|
|
693
|
+
*/
|
|
451
694
|
readonly EMAIL_EXHAUSTED: "EMAIL_EXHAUSTED";
|
|
695
|
+
/**
|
|
696
|
+
* Legacy spelling of `EMAIL_LIMIT_REACHED` from servers that still enforce
|
|
697
|
+
* one live agent per email. Retired server-side; mapped to
|
|
698
|
+
* `EmailLimitReachedError` so callers never branch on it.
|
|
699
|
+
*/
|
|
700
|
+
readonly EMAIL_TAKEN: "EMAIL_TAKEN";
|
|
701
|
+
/**
|
|
702
|
+
* 409 from `POST /v1/agents/recover/verify`: the email backs more than one
|
|
703
|
+
* agent and recovery was started without a `handle`. `details.handles`
|
|
704
|
+
* lists the candidates; re-run `recover()` with one of them.
|
|
705
|
+
*/
|
|
706
|
+
readonly HANDLE_REQUIRED: "HANDLE_REQUIRED";
|
|
452
707
|
readonly SUSPENDED: "SUSPENDED";
|
|
453
708
|
readonly RESTRICTED: "RESTRICTED";
|
|
454
709
|
readonly CONVERSATION_NOT_FOUND: "CONVERSATION_NOT_FOUND";
|
|
@@ -687,6 +942,28 @@ interface RegisterResult {
|
|
|
687
942
|
pending_id: string;
|
|
688
943
|
message: string;
|
|
689
944
|
}
|
|
945
|
+
/** Options for `AgentChatClient.recover()`. */
|
|
946
|
+
interface RecoverOptions {
|
|
947
|
+
/**
|
|
948
|
+
* Handle of the agent to recover. **Required when the email backs more
|
|
949
|
+
* than one agent; always pass it.** Optional here only for backward
|
|
950
|
+
* compatibility: without it the server can resolve the target only while
|
|
951
|
+
* the email backs exactly one live agent, and `recoverVerify()` throws
|
|
952
|
+
* `HandleRequiredError` otherwise.
|
|
953
|
+
*/
|
|
954
|
+
handle?: string;
|
|
955
|
+
baseUrl?: string;
|
|
956
|
+
clientIdentity?: AgentChatClientIdentity;
|
|
957
|
+
}
|
|
958
|
+
/**
|
|
959
|
+
* Response of `AgentChatClient.recover()`. Always present in full — the
|
|
960
|
+
* server masks a missing or mismatched handle/email pair behind the same
|
|
961
|
+
* shape to prevent email-existence enumeration.
|
|
962
|
+
*/
|
|
963
|
+
interface RecoverResult {
|
|
964
|
+
pending_id: string;
|
|
965
|
+
message: string;
|
|
966
|
+
}
|
|
690
967
|
interface ContactEntry {
|
|
691
968
|
handle: string;
|
|
692
969
|
display_name: string | null;
|
|
@@ -781,11 +1058,63 @@ interface CallOptions {
|
|
|
781
1058
|
*/
|
|
782
1059
|
idempotencyKey?: string;
|
|
783
1060
|
}
|
|
1061
|
+
interface InboxResource {
|
|
1062
|
+
/**
|
|
1063
|
+
* Read the inbox tray: one card per conversation with unread messages,
|
|
1064
|
+
* plus the gate question. Looking marks nothing delivered or read.
|
|
1065
|
+
*
|
|
1066
|
+
* With `waitMs` > 0 the server holds an empty tray up to that long and
|
|
1067
|
+
* answers the moment a card appears (long-poll; ceiling
|
|
1068
|
+
* `INBOX_WAIT_MAX_MS`). The per-call HTTP timeout is raised to cover the
|
|
1069
|
+
* wait unless you pass `timeoutMs` yourself.
|
|
1070
|
+
*/
|
|
1071
|
+
tray(options?: InboxTrayOptions & CallOptions): Promise<InboxTray>;
|
|
1072
|
+
}
|
|
1073
|
+
interface DecisionsResource {
|
|
1074
|
+
/**
|
|
1075
|
+
* Record the gate's verdict for one conversation. `reply` and `dismiss`
|
|
1076
|
+
* mark it read through `throughMessageId` (the card's `preview.message_id`)
|
|
1077
|
+
* and send the sender a read receipt; `defer` reads nothing and arms the
|
|
1078
|
+
* server's reminder ladder. Record every verdict, `reply` included — the
|
|
1079
|
+
* server measures the gate from these rows.
|
|
1080
|
+
*/
|
|
1081
|
+
record(conversationId: string, options: RecordReplyDecisionOptions & CallOptions): Promise<ReplyDecision>;
|
|
1082
|
+
}
|
|
1083
|
+
interface ConversationsResource {
|
|
1084
|
+
/**
|
|
1085
|
+
* Mark a conversation read through `throughMessageId` (inclusive) without
|
|
1086
|
+
* recording a verdict — the explicit "I looked". Fetching history never
|
|
1087
|
+
* reads; only this call or a `reply` / `dismiss` verdict does. Throws
|
|
1088
|
+
* `NotFoundError` when the anchor is not a message of this conversation.
|
|
1089
|
+
*/
|
|
1090
|
+
markRead(conversationId: string, throughMessageId: string, options?: CallOptions): Promise<MarkConversationReadResult>;
|
|
1091
|
+
}
|
|
1092
|
+
interface TextsResource {
|
|
1093
|
+
/**
|
|
1094
|
+
* Fetch the texts an agent sees (wake instruction, invite prompt, identity
|
|
1095
|
+
* line, manual pointer), with tool names spelled for `runtime`. Fetch at
|
|
1096
|
+
* start and refresh on a timer (the server suggests 24 h); never bundle a
|
|
1097
|
+
* copy.
|
|
1098
|
+
*/
|
|
1099
|
+
get(options: GetTextsOptions & CallOptions): Promise<Texts>;
|
|
1100
|
+
}
|
|
784
1101
|
declare class AgentChatClient {
|
|
785
1102
|
private readonly http;
|
|
786
1103
|
private readonly onBacklogWarning?;
|
|
787
1104
|
readonly baseUrl: string;
|
|
1105
|
+
/** The tray (`GET /v1/inbox`). */
|
|
1106
|
+
readonly inbox: InboxResource;
|
|
1107
|
+
/** Gate verdicts (`POST /v1/conversations/{id}/decisions`). */
|
|
1108
|
+
readonly decisions: DecisionsResource;
|
|
1109
|
+
/** Conversation read state (`POST /v1/conversations/{id}/read`). */
|
|
1110
|
+
readonly conversations: ConversationsResource;
|
|
1111
|
+
/** Served texts (`GET /v1/texts`). */
|
|
1112
|
+
readonly texts: TextsResource;
|
|
788
1113
|
constructor(options: AgentChatClientOptions);
|
|
1114
|
+
private getInboxTray;
|
|
1115
|
+
private recordDecision;
|
|
1116
|
+
private markConversationRead;
|
|
1117
|
+
private getTexts;
|
|
789
1118
|
private get;
|
|
790
1119
|
private del;
|
|
791
1120
|
private post;
|
|
@@ -796,6 +1125,14 @@ declare class AgentChatClient {
|
|
|
796
1125
|
* Start registration. Creates a pending agent row and emails a 6-digit
|
|
797
1126
|
* OTP to `email`. Complete the flow by calling `verify()` with the
|
|
798
1127
|
* returned `pending_id` and the OTP code.
|
|
1128
|
+
*
|
|
1129
|
+
* One email can back several agents — each registers and verifies
|
|
1130
|
+
* separately and gets its own handle and API key. The caps are
|
|
1131
|
+
* server-enforced and tunable: throws `EmailLimitReachedError` when the
|
|
1132
|
+
* email already backs the maximum number of live agents (delete one to
|
|
1133
|
+
* free a slot) and `EmailExhaustedError` when its lifetime registration
|
|
1134
|
+
* budget is spent (use another email; `+` aliases count as distinct).
|
|
1135
|
+
* Both carry the cap in `limit`.
|
|
799
1136
|
*/
|
|
800
1137
|
static register(options: RegisterOptions): Promise<RegisterResult>;
|
|
801
1138
|
/**
|
|
@@ -813,18 +1150,29 @@ declare class AgentChatClient {
|
|
|
813
1150
|
client: AgentChatClient;
|
|
814
1151
|
}>;
|
|
815
1152
|
/**
|
|
816
|
-
* Start account recovery. The server emails
|
|
817
|
-
* `recoverVerify()` with the `pending_id` and
|
|
818
|
-
*
|
|
819
|
-
*
|
|
1153
|
+
* Start account recovery for a lost API key. The server emails a 6-digit
|
|
1154
|
+
* OTP to the address; call `recoverVerify()` with the `pending_id` and
|
|
1155
|
+
* code to receive a new key.
|
|
1156
|
+
*
|
|
1157
|
+
* `options.handle` names the agent to recover. It is **required when the
|
|
1158
|
+
* email backs more than one agent; always pass it.** Without it the
|
|
1159
|
+
* server can resolve the target only while the email backs exactly one
|
|
1160
|
+
* live agent, and `recoverVerify()` throws `HandleRequiredError`.
|
|
1161
|
+
*
|
|
1162
|
+
* Always resolves to `{ pending_id, message }` — a missing or mismatched
|
|
1163
|
+
* account is masked to prevent email-existence enumeration, so a
|
|
1164
|
+
* successful return is not proof the pair exists.
|
|
1165
|
+
*/
|
|
1166
|
+
static recover(email: string, options?: RecoverOptions): Promise<RecoverResult>;
|
|
1167
|
+
/**
|
|
1168
|
+
* Complete recovery by verifying the OTP. Returns the handle, the new API
|
|
1169
|
+
* key, and an `AgentChatClient` already bound to it. **The key is shown
|
|
1170
|
+
* only once — store it securely.**
|
|
1171
|
+
*
|
|
1172
|
+
* Throws `HandleRequiredError` when `recover()` ran without `handle` for
|
|
1173
|
+
* an email that backs several agents; its `handles` lists them. The OTP
|
|
1174
|
+
* is consumed either way — start over with `handle` set.
|
|
820
1175
|
*/
|
|
821
|
-
static recover(email: string, options?: {
|
|
822
|
-
baseUrl?: string;
|
|
823
|
-
clientIdentity?: AgentChatClientIdentity;
|
|
824
|
-
}): Promise<{
|
|
825
|
-
pending_id?: string;
|
|
826
|
-
message: string;
|
|
827
|
-
}>;
|
|
828
1176
|
static recoverVerify(pendingId: string, code: string, options?: {
|
|
829
1177
|
baseUrl?: string;
|
|
830
1178
|
clientIdentity?: AgentChatClientIdentity;
|
|
@@ -1203,9 +1551,12 @@ declare class AgentChatClient {
|
|
|
1203
1551
|
* server negotiated delivery acks, the ack is sent only after every handler
|
|
1204
1552
|
* settled without throwing — a rejected handler leaves the message unacked
|
|
1205
1553
|
* so the server re-offers it (at-least-once; the dedup cache absorbs the
|
|
1206
|
-
* eventual duplicate of anything that DID succeed).
|
|
1554
|
+
* eventual duplicate of anything that DID succeed). With `ackOnReceipt` the
|
|
1555
|
+
* ack goes out before handlers run and completion no longer gates it.
|
|
1207
1556
|
*/
|
|
1208
1557
|
type MessageHandler = (message: WsMessage) => void | Promise<void>;
|
|
1558
|
+
/** Handler for `wake` frames: a content-free "check AgentChat" signal. */
|
|
1559
|
+
type WakeHandler = (frame: WakeFrame) => void | Promise<void>;
|
|
1209
1560
|
type ErrorHandler = (error: Error) => void;
|
|
1210
1561
|
/**
|
|
1211
1562
|
* Fired once per successful HELLO_ACK. Useful for updating UI ("connected"
|
|
@@ -1214,19 +1565,56 @@ type ErrorHandler = (error: Error) => void;
|
|
|
1214
1565
|
* handshake completes.
|
|
1215
1566
|
*/
|
|
1216
1567
|
type ConnectHandler = () => void;
|
|
1217
|
-
/**
|
|
1218
|
-
|
|
1568
|
+
/** Close information handed to `onDisconnect` on every socket close. */
|
|
1569
|
+
interface DisconnectInfo {
|
|
1219
1570
|
code: number;
|
|
1220
1571
|
reason: string;
|
|
1221
1572
|
wasClean: boolean;
|
|
1222
|
-
|
|
1573
|
+
/**
|
|
1574
|
+
* Who ended the socket. `'client'` is this client's own watchdog (the
|
|
1575
|
+
* handshake or liveness deadline): such a close says nothing about the
|
|
1576
|
+
* server and always takes the normal reconnect backoff. `'server'` is a
|
|
1577
|
+
* close that arrived on the wire — the server, a proxy, or the network.
|
|
1578
|
+
*/
|
|
1579
|
+
initiator: 'client' | 'server';
|
|
1580
|
+
}
|
|
1581
|
+
/** Fired on every socket close, regardless of reason. */
|
|
1582
|
+
type DisconnectHandler = (info: DisconnectInfo) => void;
|
|
1583
|
+
/**
|
|
1584
|
+
* Connection lifecycle. `stopped` is the only terminal state and only
|
|
1585
|
+
* `disconnect()` reaches it; every other state leads back to `connecting`
|
|
1586
|
+
* on its own.
|
|
1587
|
+
*
|
|
1588
|
+
* - `idle` — no socket and nothing scheduled: before the first `connect()`,
|
|
1589
|
+
* or after a close with `reconnect: false`.
|
|
1590
|
+
* - `connecting` — a socket is opening, or its HELLO awaits `hello.ok`.
|
|
1591
|
+
* - `ready` — `hello.ok` received; frames flow.
|
|
1592
|
+
* - `backoff` — the socket closed; the next attempt is scheduled with
|
|
1593
|
+
* exponential backoff.
|
|
1594
|
+
* - `blocked` — the server rejected the credential during the handshake; a
|
|
1595
|
+
* fresh attempt is scheduled every 10–15 minutes until one is accepted.
|
|
1596
|
+
* - `stopped` — `disconnect()` was called.
|
|
1597
|
+
*/
|
|
1598
|
+
type RealtimeState = 'idle' | 'connecting' | 'ready' | 'backoff' | 'blocked' | 'stopped';
|
|
1599
|
+
type StateHandler = (state: RealtimeState, previous: RealtimeState) => void;
|
|
1600
|
+
/** Why the client is `blocked`, and when it will try again. */
|
|
1601
|
+
interface BlockedInfo {
|
|
1602
|
+
/** Close code the server rejected the handshake with: 4401, 4403 or 1008. */
|
|
1603
|
+
code: number;
|
|
1604
|
+
/** The server's close reason, e.g. `Invalid token`. */
|
|
1605
|
+
reason: string;
|
|
1606
|
+
/** Milliseconds until the next automatic attempt; `null` when `reconnect` is off. */
|
|
1607
|
+
retryInMs: number | null;
|
|
1608
|
+
}
|
|
1609
|
+
type BlockedHandler = (info: BlockedInfo) => void;
|
|
1610
|
+
type StoppedHandler = () => void;
|
|
1223
1611
|
interface SequenceGapInfo {
|
|
1224
1612
|
conversationId: string;
|
|
1225
1613
|
expectedSeq: number;
|
|
1226
1614
|
bufferedSeq: number | null;
|
|
1227
1615
|
gapMs: number;
|
|
1228
1616
|
recovered: boolean;
|
|
1229
|
-
reason: 'gap_filled' | 'gap_fill_failed' | 'gap_fill_unavailable' | 'buffer_overflow';
|
|
1617
|
+
reason: 'gap_filled' | 'gap_fill_failed' | 'gap_fill_unavailable' | 'buffer_overflow' | 'connection_closed';
|
|
1230
1618
|
}
|
|
1231
1619
|
type SequenceGapHandler = (info: SequenceGapInfo) => void;
|
|
1232
1620
|
interface RealtimeOptions {
|
|
@@ -1237,17 +1625,30 @@ interface RealtimeOptions {
|
|
|
1237
1625
|
* for direct SDK use (`typescript_sdk/<SDK version>`).
|
|
1238
1626
|
*/
|
|
1239
1627
|
clientIdentity?: AgentChatClientIdentity;
|
|
1240
|
-
/**
|
|
1628
|
+
/**
|
|
1629
|
+
* Reconnect after every close that is not `disconnect()`. Default: `true`.
|
|
1630
|
+
* With `false` the client goes `idle` after a close and waits for the next
|
|
1631
|
+
* `connect()`; it never reconnects or retries on its own.
|
|
1632
|
+
*/
|
|
1241
1633
|
reconnect?: boolean;
|
|
1242
1634
|
/**
|
|
1243
|
-
* Initial reconnect delay in milliseconds.
|
|
1244
|
-
*
|
|
1245
|
-
* `maxReconnectInterval
|
|
1635
|
+
* Initial reconnect delay in milliseconds. Each consecutive failure
|
|
1636
|
+
* doubles it, jittered up to 25% below the step, up to
|
|
1637
|
+
* `maxReconnectInterval` (a true ceiling). Default: 500ms.
|
|
1246
1638
|
*/
|
|
1247
1639
|
reconnectInterval?: number;
|
|
1248
|
-
/**
|
|
1640
|
+
/**
|
|
1641
|
+
* Cap on the delay between reconnect attempts for the first 60 consecutive
|
|
1642
|
+
* failures. Default: 30s. After 60 consecutive failures the cap widens to
|
|
1643
|
+
* five minutes (or this value, if larger), one error is emitted through
|
|
1644
|
+
* `onError`, and the client keeps trying forever. There is no attempt
|
|
1645
|
+
* limit: only `disconnect()` ends the client.
|
|
1646
|
+
*/
|
|
1249
1647
|
maxReconnectInterval?: number;
|
|
1250
|
-
/**
|
|
1648
|
+
/**
|
|
1649
|
+
* @deprecated Ignored — the client never gives up on its own; only
|
|
1650
|
+
* `disconnect()` ends it. Kept so existing call sites compile.
|
|
1651
|
+
*/
|
|
1251
1652
|
maxReconnectAttempts?: number;
|
|
1252
1653
|
/**
|
|
1253
1654
|
* Optional client used for in-order recovery AND for the post-reconnect
|
|
@@ -1288,6 +1689,27 @@ interface RealtimeOptions {
|
|
|
1288
1689
|
* duplicate dispatch while still acknowledging receipt. Default: 2048.
|
|
1289
1690
|
*/
|
|
1290
1691
|
dedupCacheSize?: number;
|
|
1692
|
+
/**
|
|
1693
|
+
* Acknowledge each `message.new` the moment its frame is parsed, before
|
|
1694
|
+
* any handler runs. This is the integration setting: "delivered" then
|
|
1695
|
+
* means the agent's machine received the message, and whether the agent
|
|
1696
|
+
* has looked is tracked separately as read state (a verdict or
|
|
1697
|
+
* `client.conversations.markRead`), so an early ack never empties the
|
|
1698
|
+
* tray. Covers live frames, the server's reconnect backlog and gap-fill
|
|
1699
|
+
* rows; the REST offline drain keeps its settle-then-ack cursor. Default
|
|
1700
|
+
* `false`: ack after every handler settled, for app clients whose
|
|
1701
|
+
* handler IS the processing.
|
|
1702
|
+
*
|
|
1703
|
+
* Trade-off: an acked frame is never re-offered by the server, so a frame
|
|
1704
|
+
* that is parked on a seq gap when the socket drops is handed to the
|
|
1705
|
+
* handlers at close time, in seq order but possibly ahead of the seqs it
|
|
1706
|
+
* was waiting for (which arrive after the reconnect). Ack-on-receipt
|
|
1707
|
+
* trades strict ordering across a connection drop for no loss; the
|
|
1708
|
+
* default mode keeps ordering because unacked frames come back in order
|
|
1709
|
+
* on the next drain. Such a flush fires `onSequenceGap` with
|
|
1710
|
+
* `reason: 'connection_closed'`.
|
|
1711
|
+
*/
|
|
1712
|
+
ackOnReceipt?: boolean;
|
|
1291
1713
|
/**
|
|
1292
1714
|
* Override the WebSocket constructor. Defaults to `globalThis.WebSocket`
|
|
1293
1715
|
* with a dynamic-import fallback to the `ws` package (for Node 20).
|
|
@@ -1295,9 +1717,43 @@ interface RealtimeOptions {
|
|
|
1295
1717
|
* can supply their own implementation — anything that matches the
|
|
1296
1718
|
* browser WebSocket shape (`onopen/onmessage/onclose/onerror`, `send`,
|
|
1297
1719
|
* `close`, `readyState`) works.
|
|
1720
|
+
*
|
|
1721
|
+
* On Node the default resolution prefers `WebSocket` from the `ws`
|
|
1722
|
+
* package when it is installed and falls back to the native socket only
|
|
1723
|
+
* without it: `ws` exposes the server's ping frames (`on('ping')`), which
|
|
1724
|
+
* lets the liveness watchdog tell a quiet-but-healthy socket from a dead
|
|
1725
|
+
* one. The browser-shaped socket (including Node's native one) cannot see
|
|
1726
|
+
* pings — see `livenessTimeoutMs`. Pass a constructor only to override.
|
|
1298
1727
|
*/
|
|
1299
1728
|
webSocket?: typeof globalThis.WebSocket;
|
|
1729
|
+
/**
|
|
1730
|
+
* Handshake deadline: milliseconds from `connect()` to `hello.ok`. A
|
|
1731
|
+
* half-open upgrade or a server that never answers HELLO is closed by the
|
|
1732
|
+
* client at this point and reconnected with the normal backoff. The
|
|
1733
|
+
* server's own HELLO timer is 5 s, so this is the safety net for a dead
|
|
1734
|
+
* pipe, not the common path. Default: 15 000.
|
|
1735
|
+
*/
|
|
1736
|
+
handshakeTimeoutMs?: number;
|
|
1737
|
+
/**
|
|
1738
|
+
* Idle deadline: milliseconds without any inbound frame — or, on a socket
|
|
1739
|
+
* that exposes them, a ping — before the connection is presumed dead,
|
|
1740
|
+
* closed by the client and reconnected. The server pings every 45 s, so
|
|
1741
|
+
* the default (100 000) survives one missed ping and trips on the second.
|
|
1742
|
+
*
|
|
1743
|
+
* Ping frames are visible only on a socket with `on('ping')` (Node `ws`).
|
|
1744
|
+
* A browser-shaped socket cannot see them, so there the idle deadline is
|
|
1745
|
+
* OFF unless set explicitly: only application frames would keep it alive,
|
|
1746
|
+
* and an idle but healthy connection would otherwise be reopened every
|
|
1747
|
+
* cycle. `0` disables it on any socket; the handshake deadline stays.
|
|
1748
|
+
*/
|
|
1749
|
+
livenessTimeoutMs?: number;
|
|
1300
1750
|
}
|
|
1751
|
+
/**
|
|
1752
|
+
* True iff a server-originated close with this code and reason, received
|
|
1753
|
+
* before `hello.ok`, means the credential was rejected. Pure; exported so
|
|
1754
|
+
* integrations and tests share one definition.
|
|
1755
|
+
*/
|
|
1756
|
+
declare function isAuthRejectionClose(code: number, reason: string): boolean;
|
|
1301
1757
|
declare class RealtimeClient {
|
|
1302
1758
|
private ws;
|
|
1303
1759
|
private options;
|
|
@@ -1305,6 +1761,11 @@ declare class RealtimeClient {
|
|
|
1305
1761
|
private errorHandlers;
|
|
1306
1762
|
private connectHandlers;
|
|
1307
1763
|
private disconnectHandlers;
|
|
1764
|
+
private stateHandlers;
|
|
1765
|
+
private blockedHandlers;
|
|
1766
|
+
private stoppedHandlers;
|
|
1767
|
+
private _state;
|
|
1768
|
+
/** Consecutive failed attempts; drives the backoff. Cleared by the stability timer only. */
|
|
1308
1769
|
private reconnectAttempts;
|
|
1309
1770
|
/** Clears reconnectAttempts once this connection proves itself stable. */
|
|
1310
1771
|
private stabilityTimer;
|
|
@@ -1312,11 +1773,21 @@ declare class RealtimeClient {
|
|
|
1312
1773
|
* the operator warning only; backoff itself uses reconnectAttempts. */
|
|
1313
1774
|
private rapidReconnects;
|
|
1314
1775
|
private lastConnectAt;
|
|
1776
|
+
/** The pending backoff or blocked-retry timer — at most one at a time. */
|
|
1315
1777
|
private reconnectTimer;
|
|
1316
|
-
|
|
1778
|
+
/** Handshake deadline: armed by connect(), cleared by hello.ok or close. */
|
|
1779
|
+
private handshakeTimer;
|
|
1780
|
+
/** Idle deadline: armed by hello.ok; inbound frames and pings refresh it. */
|
|
1781
|
+
private livenessTimer;
|
|
1782
|
+
/** Idle deadline in effect for the current socket; 0 = off. */
|
|
1783
|
+
private livenessMs;
|
|
1784
|
+
private lastInboundAt;
|
|
1317
1785
|
private authenticated;
|
|
1318
1786
|
private ackMode;
|
|
1319
|
-
|
|
1787
|
+
/** One error per long outage, then silent until a stable connection. */
|
|
1788
|
+
private longOutageAnnounced;
|
|
1789
|
+
/** One error per run of rejected handshakes, then silent until hello.ok. */
|
|
1790
|
+
private blockedAnnounced;
|
|
1320
1791
|
private dedupSeen;
|
|
1321
1792
|
private restDrainOrigin;
|
|
1322
1793
|
private drainSettlements;
|
|
@@ -1326,12 +1797,16 @@ declare class RealtimeClient {
|
|
|
1326
1797
|
constructor(options: RealtimeOptions);
|
|
1327
1798
|
/**
|
|
1328
1799
|
* Open the WebSocket connection and perform the HELLO handshake.
|
|
1329
|
-
* Resolves once the socket
|
|
1330
|
-
* NOT after `hello.ok`. Listen for `onConnect()`
|
|
1331
|
-
* completed handshake.
|
|
1800
|
+
* Resolves once the socket has been constructed and its handlers bound —
|
|
1801
|
+
* NOT after `hello.ok`. Listen for `onConnect()` or `on('state')` to react
|
|
1802
|
+
* to a completed handshake.
|
|
1332
1803
|
*
|
|
1333
|
-
*
|
|
1334
|
-
*
|
|
1804
|
+
* Also the way to retry at once: called while `backoff` or `blocked`, it
|
|
1805
|
+
* cancels the pending timer and opens a socket now. A no-op while a socket
|
|
1806
|
+
* is already connecting or connected. Throws after `disconnect()` — create
|
|
1807
|
+
* a fresh `RealtimeClient` instead. Rejects, without retrying, when no
|
|
1808
|
+
* WebSocket implementation exists (neither `ws` nor a native one): that is
|
|
1809
|
+
* a configuration error and the client stays `idle`.
|
|
1335
1810
|
*/
|
|
1336
1811
|
connect(): Promise<void>;
|
|
1337
1812
|
/**
|
|
@@ -1385,11 +1860,87 @@ declare class RealtimeClient {
|
|
|
1385
1860
|
* Track short-lived connections and warn once they form a pattern.
|
|
1386
1861
|
* A flapping client looks healthy from the inside — every reconnect
|
|
1387
1862
|
* succeeds — so without this the operator has no local signal at all.
|
|
1863
|
+
* The notice goes through `onError` like every other signal: an SDK
|
|
1864
|
+
* that runs as a guest inside a host process does not own its console.
|
|
1388
1865
|
*/
|
|
1389
1866
|
private noteConnectionEnded;
|
|
1867
|
+
/**
|
|
1868
|
+
* The single funnel for "this socket is over", whoever ended it. Runs
|
|
1869
|
+
* after `this.ws` has been let go of, so nothing here touches the socket
|
|
1870
|
+
* again. Decides what comes next — backoff, blocked or idle, never nothing.
|
|
1871
|
+
*/
|
|
1872
|
+
private handleClose;
|
|
1873
|
+
/**
|
|
1874
|
+
* End the current socket on the client's own decision (a watchdog trip,
|
|
1875
|
+
* a HELLO that could not be sent) and move on at once, without waiting for
|
|
1876
|
+
* the socket's close event: on a dead pipe a polite close waits for a
|
|
1877
|
+
* reply that never comes. Terminated where the API allows it (Node `ws`),
|
|
1878
|
+
* closed otherwise; its own late events are ignored because it is no
|
|
1879
|
+
* longer `this.ws`.
|
|
1880
|
+
*/
|
|
1881
|
+
private abandonSocket;
|
|
1390
1882
|
private scheduleReconnect;
|
|
1883
|
+
/**
|
|
1884
|
+
* The server rejected the credential. `blocked` is not the end: a fresh
|
|
1885
|
+
* HELLO goes out every AUTH_RETRY_INTERVAL_MS (jittered) until one is
|
|
1886
|
+
* accepted — keys get rotated back and accounts get reinstated, and the
|
|
1887
|
+
* running client has no other way to learn it. The first rejection of a
|
|
1888
|
+
* run is an error; the following ones only fire `blocked`, so an operator
|
|
1889
|
+
* sees one line per incident rather than one every quarter hour.
|
|
1890
|
+
*/
|
|
1891
|
+
private enterBlocked;
|
|
1892
|
+
/**
|
|
1893
|
+
* The timer-driven attempt. connect() emits and re-arms on its own for
|
|
1894
|
+
* every failure it retries (a throwing constructor, a close); the one
|
|
1895
|
+
* failure it does not retry — no WebSocket implementation at all — left
|
|
1896
|
+
* nothing armed, so it is announced here: the operator should see why the
|
|
1897
|
+
* client went quiet.
|
|
1898
|
+
*/
|
|
1899
|
+
private retryNow;
|
|
1900
|
+
private clearReconnectTimer;
|
|
1391
1901
|
private computeReconnectDelay;
|
|
1902
|
+
private longOutageCap;
|
|
1903
|
+
/** Symmetric ±ratio jitter around `ms` — for the blocked retry, a range (10–15 min), not a cap. */
|
|
1904
|
+
private jittered;
|
|
1905
|
+
/** Jitter in [ms × (1 − ratio), ms]: `ms` is a ceiling. Thundering-herd-safe across a fleet. */
|
|
1906
|
+
private jitteredBelow;
|
|
1907
|
+
private armHandshakeDeadline;
|
|
1908
|
+
/**
|
|
1909
|
+
* Note proof of life (any inbound frame, or a ping/pong on a socket that
|
|
1910
|
+
* shows them). The timer itself is lazy: it is armed once per connection
|
|
1911
|
+
* and, when it fires early because traffic arrived meanwhile, re-arms for
|
|
1912
|
+
* the remainder — one `Date.now()` per frame instead of a timer churn.
|
|
1913
|
+
*/
|
|
1914
|
+
private touchLiveness;
|
|
1915
|
+
private armLiveness;
|
|
1916
|
+
private clearHandshakeTimer;
|
|
1917
|
+
private clearWatchdogs;
|
|
1918
|
+
private setState;
|
|
1919
|
+
/**
|
|
1920
|
+
* Subscribe to one event type. `wake` handlers receive a typed
|
|
1921
|
+
* `WakeFrame`; the frame carries no message and is never acknowledged.
|
|
1922
|
+
* Returns an unsubscribe function.
|
|
1923
|
+
*
|
|
1924
|
+
* Three events are the client's own rather than server frames:
|
|
1925
|
+
* - `state` — every transition of `state` (see `RealtimeState`).
|
|
1926
|
+
* - `blocked` — the server rejected the credential during the handshake;
|
|
1927
|
+
* carries the close code, reason and the delay to the next attempt.
|
|
1928
|
+
* - `stopped` — `disconnect()` was called; fired once, before handlers
|
|
1929
|
+
* are released.
|
|
1930
|
+
*/
|
|
1931
|
+
on(event: 'wake', handler: WakeHandler): () => void;
|
|
1932
|
+
on(event: 'state', handler: StateHandler): () => void;
|
|
1933
|
+
on(event: 'blocked', handler: BlockedHandler): () => void;
|
|
1934
|
+
on(event: 'stopped', handler: StoppedHandler): () => void;
|
|
1392
1935
|
on(event: string, handler: MessageHandler): () => void;
|
|
1936
|
+
private subscribe;
|
|
1937
|
+
/**
|
|
1938
|
+
* Every signal the client has for its operator comes through here:
|
|
1939
|
+
* transport errors, handler failures, the watchdog and backoff notices
|
|
1940
|
+
* (`handshake timeout`, `liveness timeout`, `still reconnecting after
|
|
1941
|
+
* 60 …`, `server rejected the credential …`, `connection is unstable`).
|
|
1942
|
+
* The SDK never writes to the console.
|
|
1943
|
+
*/
|
|
1393
1944
|
onError(handler: ErrorHandler): () => void;
|
|
1394
1945
|
/** Fires each time the handshake completes (initial + every reconnect). */
|
|
1395
1946
|
onConnect(handler: ConnectHandler): () => void;
|
|
@@ -1415,10 +1966,21 @@ declare class RealtimeClient {
|
|
|
1415
1966
|
sendReadAck(conversationId: string, throughSeq: number): void;
|
|
1416
1967
|
/** `true` after a completed HELLO handshake and before the next close. */
|
|
1417
1968
|
get isConnected(): boolean;
|
|
1969
|
+
/** Where the connection lifecycle is right now. See `RealtimeState`. */
|
|
1970
|
+
get state(): RealtimeState;
|
|
1418
1971
|
/**
|
|
1419
|
-
*
|
|
1420
|
-
*
|
|
1421
|
-
* `
|
|
1972
|
+
* `true` when the current connection's `hello.ok` echoed the `ack`
|
|
1973
|
+
* capability: the server keeps each envelope `stored` until this client
|
|
1974
|
+
* acknowledges it. `false` before `hello.ok`, after a close, and against
|
|
1975
|
+
* a legacy server (which marks envelopes delivered on push).
|
|
1976
|
+
*/
|
|
1977
|
+
get ackNegotiated(): boolean;
|
|
1978
|
+
/**
|
|
1979
|
+
* Close the socket, cancel every timer, and release all handlers. The
|
|
1980
|
+
* only way into `stopped`, and the only way the client ever stops on
|
|
1981
|
+
* purpose: works from any state (`blocked` and a pending backoff
|
|
1982
|
+
* included). `stopped` fires once. After this, `connect()` throws —
|
|
1983
|
+
* create a fresh `RealtimeClient` if you want to reopen.
|
|
1422
1984
|
*/
|
|
1423
1985
|
disconnect(): void;
|
|
1424
1986
|
private emitError;
|
|
@@ -1453,6 +2015,16 @@ declare class RealtimeClient {
|
|
|
1453
2015
|
private dedupAdd;
|
|
1454
2016
|
private extractMessageId;
|
|
1455
2017
|
private isMessageNew;
|
|
2018
|
+
private isWake;
|
|
2019
|
+
/**
|
|
2020
|
+
* A `wake` frame is a content-free signal: validate the payload shape
|
|
2021
|
+
* (so `wake` handlers can trust the `WakeFrame` type), then dispatch. A
|
|
2022
|
+
* frame the server sent malformed is surfaced through `onError` rather
|
|
2023
|
+
* than handed to handlers as something it is not. Never acked — there is
|
|
2024
|
+
* no message to deliver.
|
|
2025
|
+
*/
|
|
2026
|
+
private dispatchWake;
|
|
2027
|
+
private wakePayloadProblem;
|
|
1456
2028
|
private processOrderedMessage;
|
|
1457
2029
|
private handleGapTimer;
|
|
1458
2030
|
private drainConsecutive;
|
|
@@ -1463,7 +2035,213 @@ declare class RealtimeClient {
|
|
|
1463
2035
|
private extractSeq;
|
|
1464
2036
|
private minBufferedSeq;
|
|
1465
2037
|
private resetOrderStates;
|
|
1466
|
-
private
|
|
2038
|
+
private flushParkedFrames;
|
|
2039
|
+
}
|
|
2040
|
+
|
|
2041
|
+
/**
|
|
2042
|
+
* The gate: the agent's own model answers the server's question about the
|
|
2043
|
+
* server's cards, and the verdicts are recorded.
|
|
2044
|
+
*
|
|
2045
|
+
* Code we keep, brain we don't
|
|
2046
|
+
* ────────────────────────────
|
|
2047
|
+
* Every word the model reads about AgentChat comes from the tray: the gate
|
|
2048
|
+
* question (`tray.question`) and the categories (`tray.categories`) are
|
|
2049
|
+
* rendered verbatim, and each card is rendered as the server built it. This
|
|
2050
|
+
* module adds a preamble that frames the call as a tool-less triage, the
|
|
2051
|
+
* output-shape wrapper, the parser, and the recording through
|
|
2052
|
+
* `client.decisions.record`. No model runs here: the host passes
|
|
2053
|
+
* `callModel(prompt) => Promise<string>` so the judgement is the agent's own
|
|
2054
|
+
* model, in the host's own harness. That call MUST be a plain completion
|
|
2055
|
+
* with no tools attached: the served question mentions tools, and a model
|
|
2056
|
+
* that could call them would act instead of answering.
|
|
2057
|
+
*
|
|
2058
|
+
* What gets recorded, and when
|
|
2059
|
+
* ────────────────────────────
|
|
2060
|
+
* `dismiss` and `defer` are recorded at once, each anchored to the card's
|
|
2061
|
+
* `preview.message_id` (`last_message_id` when a card has no preview).
|
|
2062
|
+
* `reply` is NOT recorded by `run`: recording it marks the conversation read
|
|
2063
|
+
* and takes it off the tray, and a turn that then fails to start (budget,
|
|
2064
|
+
* missing binary, refused) would leave a read conversation with nothing
|
|
2065
|
+
* sent and no way back. Each reply comes back with a `record()` the host
|
|
2066
|
+
* calls right after the turn has started — not after it finishes;
|
|
2067
|
+
* crash-after-start is the accepted trade-off. A host that never calls it
|
|
2068
|
+
* leaves the conversation unread, and the next wake gates it again.
|
|
2069
|
+
*
|
|
2070
|
+
* Failure policy
|
|
2071
|
+
* ──────────────
|
|
2072
|
+
* Fail closed: when the model cannot be reached or its answer holds no
|
|
2073
|
+
* usable verdict, nothing is recorded and `reply` is empty. The messages
|
|
2074
|
+
* stay unread and on the tray; the next wake asks again. Hosts that want to
|
|
2075
|
+
* start a turn anyway can do so from `outcome === 'fail_closed'`.
|
|
2076
|
+
*
|
|
2077
|
+
* Where the two gates this replaces differed (Hermes `gate.py`, OpenClaw
|
|
2078
|
+
* `doorbell/gate.ts`), the stricter rule won:
|
|
2079
|
+
* - Dismiss synonyms: Hermes also took `close` / `closed`; OpenClaw did
|
|
2080
|
+
* not. Not accepted here — `close` collides with the `closing` category
|
|
2081
|
+
* and a category echoed into the decision slot must not pass as a verdict.
|
|
2082
|
+
* - `defer_seconds`: both parsed and posted it. Here it is ignored and
|
|
2083
|
+
* never sent — the server owns the defer timing.
|
|
2084
|
+
* - Fail-open flag: both had an environment switch that started a turn on
|
|
2085
|
+
* gate failure. There is none here; the host decides from the result.
|
|
2086
|
+
* - Retry without category on a 400: both did. Not here — the category
|
|
2087
|
+
* comes from the list the server itself served, so a 400 is a real
|
|
2088
|
+
* error and is reported in `recordFailures`.
|
|
2089
|
+
* - `reply` verdicts: both skipped posting them (recording used to settle
|
|
2090
|
+
* delivery and empty the tray). Recorded here, but only once the host
|
|
2091
|
+
* has started the turn (see above).
|
|
2092
|
+
* Everything else (JSON extraction, duplicate ids, unknown ids, unknown
|
|
2093
|
+
* decisions, category normalisation, empty answer = failure) was identical
|
|
2094
|
+
* and is kept.
|
|
2095
|
+
*/
|
|
2096
|
+
|
|
2097
|
+
/** Spell a hosted tool name the way a runtime exposes it to its model. */
|
|
2098
|
+
type ToolNamer = (tool: string) => string;
|
|
2099
|
+
/** The names as the server writes them. The default. */
|
|
2100
|
+
declare const BARE_TOOL_NAMER: ToolNamer;
|
|
2101
|
+
/**
|
|
2102
|
+
* The convention MCP-hosted coding agents use: `mcp__<server>__<tool>`.
|
|
2103
|
+
* `mcpToolNamer('agentchat')('agentchat_decide')` → `mcp__agentchat__agentchat_decide`.
|
|
2104
|
+
*/
|
|
2105
|
+
declare function mcpToolNamer(serverName: string): ToolNamer;
|
|
2106
|
+
/** One parsed answer for one card. Snake-case: it is data, shared with the conformance fixtures. */
|
|
2107
|
+
interface Verdict {
|
|
2108
|
+
conversation_id: string;
|
|
2109
|
+
decision: ReplyDecisionVerdict;
|
|
2110
|
+
/** A category from the tray's list, or null when the model gave none or an unknown one. */
|
|
2111
|
+
category: ReplyDecisionCategory | null;
|
|
2112
|
+
}
|
|
2113
|
+
interface BuildPromptOptions {
|
|
2114
|
+
/** How this runtime spells the hosted tools named inside the question. Default: as served. */
|
|
2115
|
+
toolNamer?: ToolNamer;
|
|
2116
|
+
}
|
|
2117
|
+
/**
|
|
2118
|
+
* The cards exactly as served, minus anything that is not an object with a
|
|
2119
|
+
* conversation id (a defensive filter, never a judgement).
|
|
2120
|
+
*/
|
|
2121
|
+
declare function cardsOf(tray: InboxTray): InboxCard[];
|
|
2122
|
+
/**
|
|
2123
|
+
* The message a verdict on this card reads through: the preview's message,
|
|
2124
|
+
* or the thread's newest message when the card has no preview. Undefined
|
|
2125
|
+
* only when the server gave neither (the server then reads through "now").
|
|
2126
|
+
*/
|
|
2127
|
+
declare function anchorOf(card: InboxCard): string | undefined;
|
|
2128
|
+
/**
|
|
2129
|
+
* JSON with object keys sorted at every level and two-space indentation —
|
|
2130
|
+
* the same bytes from any SDK regardless of the order the server emitted
|
|
2131
|
+
* the keys in. Values are the JSON scalar set only.
|
|
2132
|
+
*/
|
|
2133
|
+
declare function canonicalJson(value: unknown): string;
|
|
2134
|
+
/**
|
|
2135
|
+
* Render the gate prompt for one tray: a preamble that frames the call as a
|
|
2136
|
+
* tool-less triage, the server's question verbatim, the categories, one
|
|
2137
|
+
* block per card, then the output shape. Pure.
|
|
2138
|
+
*
|
|
2139
|
+
* Throws when the tray carries no question — judging without it is exactly
|
|
2140
|
+
* the drift this design removes, so the gate fails closed instead.
|
|
2141
|
+
*/
|
|
2142
|
+
declare function buildPrompt(tray: InboxTray, options?: BuildPromptOptions): string;
|
|
2143
|
+
/**
|
|
2144
|
+
* Parse the model's answer into verdicts for the cards on `tray`.
|
|
2145
|
+
*
|
|
2146
|
+
* Returns `null` when the text holds no JSON at all (nothing parsable: the
|
|
2147
|
+
* caller fails closed). Entries for conversations not on the tray, unknown
|
|
2148
|
+
* decisions and duplicate ids are dropped; those cards count as undecided.
|
|
2149
|
+
* An unknown category becomes `null`; a stray `defer_seconds` is ignored.
|
|
2150
|
+
* Tolerant of code fences, surrounding prose and the synonyms above.
|
|
2151
|
+
*/
|
|
2152
|
+
declare function parseVerdicts(text: string | null | undefined, tray: InboxTray): Verdict[] | null;
|
|
2153
|
+
/** Map a model's spelling onto a verdict, or null when it is none of the tolerated ones. */
|
|
2154
|
+
declare function normalizeDecision(value: unknown): ReplyDecisionVerdict | null;
|
|
2155
|
+
/**
|
|
2156
|
+
* The host's model call. Receives the rendered prompt, returns the model's
|
|
2157
|
+
* raw text. MUST be a plain completion with no tools attached: the served
|
|
2158
|
+
* question names hosted tools, and a model that could call them would act
|
|
2159
|
+
* instead of answering (no JSON → fail closed, or a tool call AND JSON →
|
|
2160
|
+
* a verdict recorded twice).
|
|
2161
|
+
*/
|
|
2162
|
+
type GateModelCall = (prompt: string) => Promise<string>;
|
|
2163
|
+
/** The one client surface the gate needs; `AgentChatClient` satisfies it. */
|
|
2164
|
+
type GateClient = Pick<AgentChatClient, 'decisions'>;
|
|
2165
|
+
interface RunGateOptions {
|
|
2166
|
+
tray: InboxTray;
|
|
2167
|
+
callModel: GateModelCall;
|
|
2168
|
+
client: GateClient;
|
|
2169
|
+
/** How this runtime spells the hosted tools named inside the question. */
|
|
2170
|
+
toolNamer?: ToolNamer;
|
|
2171
|
+
}
|
|
2172
|
+
type GateOutcome =
|
|
2173
|
+
/** The model answered; dismiss/defer verdicts were recorded, replies await `record()`. */
|
|
2174
|
+
'decided'
|
|
2175
|
+
/** The tray had no cards; nothing to decide. */
|
|
2176
|
+
| 'empty'
|
|
2177
|
+
/** The model call failed or its answer held no usable verdict; nothing was recorded. */
|
|
2178
|
+
| 'fail_closed';
|
|
2179
|
+
interface GateRecordFailure {
|
|
2180
|
+
conversation_id: string;
|
|
2181
|
+
error: Error;
|
|
2182
|
+
}
|
|
2183
|
+
/** A conversation the model decided needs a turn. */
|
|
2184
|
+
interface GateReply {
|
|
2185
|
+
conversationId: string;
|
|
2186
|
+
/** The card as served; the anchor `record()` uses is `anchorOf(card)`. */
|
|
2187
|
+
card: InboxCard;
|
|
2188
|
+
/** The category the model attached, if any. */
|
|
2189
|
+
category: ReplyDecisionCategory | null;
|
|
2190
|
+
/**
|
|
2191
|
+
* Record the `reply` verdict. Call it right after the turn has started —
|
|
2192
|
+
* not before (a turn that fails to start would leave the conversation
|
|
2193
|
+
* read with nothing sent), not after it finishes (crash-after-start is
|
|
2194
|
+
* the accepted trade-off). Never calling it leaves the conversation
|
|
2195
|
+
* unread; the next wake gates it again. Idempotent on success; a failed
|
|
2196
|
+
* call may be retried.
|
|
2197
|
+
*/
|
|
2198
|
+
record(): Promise<ReplyDecision>;
|
|
2199
|
+
}
|
|
2200
|
+
interface GateResult {
|
|
2201
|
+
outcome: GateOutcome;
|
|
2202
|
+
/** Conversations whose verdict is `reply`: start a turn for each, then call its `record()`. */
|
|
2203
|
+
reply: GateReply[];
|
|
2204
|
+
/** Every usable verdict, in the model's order. */
|
|
2205
|
+
verdicts: Verdict[];
|
|
2206
|
+
/** Cards the model left without a usable verdict; they stay on the tray. */
|
|
2207
|
+
undecided: string[];
|
|
2208
|
+
/** `dismiss` / `defer` verdicts the server took. */
|
|
2209
|
+
recorded: number;
|
|
2210
|
+
/** `dismiss` / `defer` verdicts the server did not take. */
|
|
2211
|
+
recordFailures: GateRecordFailure[];
|
|
2212
|
+
/** Why the gate failed closed; null otherwise. */
|
|
2213
|
+
failure: string | null;
|
|
2214
|
+
}
|
|
2215
|
+
/**
|
|
2216
|
+
* Decide every card on the tray. `dismiss` and `defer` are recorded here,
|
|
2217
|
+
* sequentially (a tray holds at most 50 cards), each anchored with
|
|
2218
|
+
* `anchorOf(card)`; `reply` verdicts come back as `GateReply` entries whose
|
|
2219
|
+
* `record()` the host calls once the turn is running. Never throws: model
|
|
2220
|
+
* and network failures land in the result.
|
|
2221
|
+
*/
|
|
2222
|
+
declare function run(options: RunGateOptions): Promise<GateResult>;
|
|
2223
|
+
|
|
2224
|
+
declare const gate_BARE_TOOL_NAMER: typeof BARE_TOOL_NAMER;
|
|
2225
|
+
type gate_BuildPromptOptions = BuildPromptOptions;
|
|
2226
|
+
type gate_GateClient = GateClient;
|
|
2227
|
+
type gate_GateModelCall = GateModelCall;
|
|
2228
|
+
type gate_GateOutcome = GateOutcome;
|
|
2229
|
+
type gate_GateRecordFailure = GateRecordFailure;
|
|
2230
|
+
type gate_GateReply = GateReply;
|
|
2231
|
+
type gate_GateResult = GateResult;
|
|
2232
|
+
type gate_RunGateOptions = RunGateOptions;
|
|
2233
|
+
type gate_ToolNamer = ToolNamer;
|
|
2234
|
+
type gate_Verdict = Verdict;
|
|
2235
|
+
declare const gate_anchorOf: typeof anchorOf;
|
|
2236
|
+
declare const gate_buildPrompt: typeof buildPrompt;
|
|
2237
|
+
declare const gate_canonicalJson: typeof canonicalJson;
|
|
2238
|
+
declare const gate_cardsOf: typeof cardsOf;
|
|
2239
|
+
declare const gate_mcpToolNamer: typeof mcpToolNamer;
|
|
2240
|
+
declare const gate_normalizeDecision: typeof normalizeDecision;
|
|
2241
|
+
declare const gate_parseVerdicts: typeof parseVerdicts;
|
|
2242
|
+
declare const gate_run: typeof run;
|
|
2243
|
+
declare namespace gate {
|
|
2244
|
+
export { gate_BARE_TOOL_NAMER as BARE_TOOL_NAMER, type gate_BuildPromptOptions as BuildPromptOptions, type gate_GateClient as GateClient, type gate_GateModelCall as GateModelCall, type gate_GateOutcome as GateOutcome, type gate_GateRecordFailure as GateRecordFailure, type gate_GateReply as GateReply, type gate_GateResult as GateResult, type gate_RunGateOptions as RunGateOptions, type gate_ToolNamer as ToolNamer, type gate_Verdict as Verdict, gate_anchorOf as anchorOf, gate_buildPrompt as buildPrompt, gate_canonicalJson as canonicalJson, gate_cardsOf as cardsOf, gate_mcpToolNamer as mcpToolNamer, gate_normalizeDecision as normalizeDecision, gate_parseVerdicts as parseVerdicts, gate_run as run };
|
|
1467
2245
|
}
|
|
1468
2246
|
|
|
1469
2247
|
/**
|
|
@@ -1562,6 +2340,54 @@ declare class GroupDeletedError extends AgentChatError {
|
|
|
1562
2340
|
readonly deletedAt: string | null;
|
|
1563
2341
|
constructor(response: AgentChatErrorResponse, status: number, requestId?: string | null);
|
|
1564
2342
|
}
|
|
2343
|
+
/**
|
|
2344
|
+
* Raised for 409 EMAIL_LIMIT_REACHED from `POST /v1/register`: the email
|
|
2345
|
+
* already backs the maximum number of *live* agents (status active /
|
|
2346
|
+
* restricted / suspended). Deleting one frees a slot; registering under a
|
|
2347
|
+
* different email (`+` aliases count as distinct) is the other way out.
|
|
2348
|
+
*
|
|
2349
|
+
* `limit` is the server's current cap from `details.limit` — quote it in
|
|
2350
|
+
* user-facing copy rather than hard-coding a number, since the operator can
|
|
2351
|
+
* tune it without a deploy. `null` when the server omitted it; fall back to
|
|
2352
|
+
* `message`.
|
|
2353
|
+
*
|
|
2354
|
+
* Servers that predate the policy reject a second registration with the
|
|
2355
|
+
* legacy `EMAIL_TAKEN` code; it maps here too.
|
|
2356
|
+
*/
|
|
2357
|
+
declare class EmailLimitReachedError extends AgentChatError {
|
|
2358
|
+
readonly limit: number | null;
|
|
2359
|
+
constructor(response: AgentChatErrorResponse, status: number, requestId?: string | null);
|
|
2360
|
+
}
|
|
2361
|
+
/**
|
|
2362
|
+
* Raised for 409 EMAIL_EXHAUSTED from `POST /v1/register`: the email has
|
|
2363
|
+
* used up its *lifetime* registration budget (every agent ever created
|
|
2364
|
+
* under it, deleted ones included). Unlike `EmailLimitReachedError`,
|
|
2365
|
+
* deleting an agent does not free a slot — register with a different email.
|
|
2366
|
+
*
|
|
2367
|
+
* `limit` is the server's current lifetime cap from `details.limit`; `null`
|
|
2368
|
+
* when omitted (fall back to `message`).
|
|
2369
|
+
*/
|
|
2370
|
+
declare class EmailExhaustedError extends AgentChatError {
|
|
2371
|
+
readonly limit: number | null;
|
|
2372
|
+
constructor(response: AgentChatErrorResponse, status: number, requestId?: string | null);
|
|
2373
|
+
}
|
|
2374
|
+
/**
|
|
2375
|
+
* Raised for 409 HANDLE_REQUIRED from `POST /v1/agents/recover/verify`.
|
|
2376
|
+
* Recovery was started with an email that backs more than one agent and no
|
|
2377
|
+
* `handle` to disambiguate, so the server could not tell which account to
|
|
2378
|
+
* re-key. The OTP has been consumed; call `AgentChatClient.recover()` again
|
|
2379
|
+
* with `handle` set to one of `handles`.
|
|
2380
|
+
*
|
|
2381
|
+
* `handles` lists every live agent on that email, oldest first. The server
|
|
2382
|
+
* reveals them only here — the caller has just proven control of the inbox
|
|
2383
|
+
* — never from the unauthenticated first step.
|
|
2384
|
+
*
|
|
2385
|
+
* Passing `handle` on the first call avoids this error entirely.
|
|
2386
|
+
*/
|
|
2387
|
+
declare class HandleRequiredError extends AgentChatError {
|
|
2388
|
+
readonly handles: string[];
|
|
2389
|
+
constructor(response: AgentChatErrorResponse, status: number, requestId?: string | null);
|
|
2390
|
+
}
|
|
1565
2391
|
/** Raised when the server returns 5xx (after retries exhaust). */
|
|
1566
2392
|
declare class ServerError extends AgentChatError {
|
|
1567
2393
|
constructor(response: AgentChatErrorResponse, status: number, requestId?: string | null);
|
|
@@ -1630,4 +2456,4 @@ declare function renderMessageContext(message: Pick<Message, 'sender' | 'created
|
|
|
1630
2456
|
|
|
1631
2457
|
declare const VERSION: string;
|
|
1632
2458
|
|
|
1633
|
-
export { ALLOWED_ATTACHMENT_MIME, type AddContactRequest, type AddMemberRequest, type AddMemberResult, type Agent, AgentChatClient, type AgentChatClientIdentity, type AgentChatClientKind, type AgentChatClientOptions, AgentChatError, type AgentChatErrorResponse, type AgentConversationContext, type AgentProfile, type AgentSettings, type AgentStatus, type ApiError, type AttachmentMime, AwaitingReplyError, type BacklogWarning, type BacklogWarningHandler, type BlockedAgent, BlockedError, type CallOptions, type ClientAction, type ConnectHandler, ConnectionError, type Contact, type Conversation, type ConversationListItem, type ConversationParticipant, type ConversationType, type CreateGroupRequest, type CreateUploadRequest, type CreateUploadResponse, DEFAULT_RETRY_POLICY, type DeletedGroupInfo, type DirectConversationLookup, type DisconnectHandler, ErrorCode, type ErrorHandler, type ErrorInfo, ForbiddenError, type Group, GroupDeletedError, type GroupDetail, type GroupInvitation, type GroupInvitePolicy, type GroupInviteRule, type GroupMember, type GroupRole, type GroupSettings, type GroupSystemEvent, type GroupSystemEventV1, type HttpMethod, type HttpRequestOptions, type HttpResponse, HttpTransport, type HttpTransportOptions, type InboxMode, MAX_ATTACHMENT_SIZE, type Message, type MessageContent, type MessageHandler, type MessageStatus, type MessageType, type MuteEntry, type MuteTargetKind, NotFoundError, type PausedByOwner, type Presence, type PresenceBatchRequest, type PresenceBroadcast, type PresenceStatus, type PresenceUpdate, RateLimitedError, RealtimeClient, type RealtimeOptions, RecipientBackloggedError, type RegisterRequest, type RenderOptions, type ReportRequest, type RequestHooks, type RequestInfo, type ResponseInfo, RestrictedError, type RetryInfo, type RetryOption, type RetryPolicy, type SendMessageRequest, type SendMessageResult, type SequenceGapHandler, type SequenceGapInfo, ServerError, type ServerEvent, SuspendedError, type SyncEnvelope, UnauthorizedError, type UpdateAgentRequest, type UpdateContactRequest, type UpdateGroupRequest, VERSION, ValidationError, type VerifyRequest, type WsMessage, createAgentChatError, paginate, parseRetryAfter, renderMessageContext };
|
|
2459
|
+
export { ALLOWED_ATTACHMENT_MIME, type AckFrame, type AddContactRequest, type AddMemberRequest, type AddMemberResult, type Agent, AgentChatClient, type AgentChatClientIdentity, type AgentChatClientKind, type AgentChatClientOptions, AgentChatError, type AgentChatErrorResponse, type AgentConversationContext, type AgentProfile, type AgentSettings, type AgentStatus, type ApiError, type AttachmentMime, AwaitingReplyError, type BacklogWarning, type BacklogWarningHandler, type BlockedAgent, BlockedError, type BlockedHandler, type BlockedInfo, type BuildPromptOptions, type CallOptions, type ClientAction, type ConnectHandler, ConnectionError, type Contact, type Conversation, type ConversationListItem, type ConversationParticipant, type ConversationType, type ConversationsResource, type CreateGroupRequest, type CreateUploadRequest, type CreateUploadResponse, DEFAULT_RETRY_POLICY, type DecisionsResource, type DeletedGroupInfo, type DirectConversationLookup, type DisconnectHandler, type DisconnectInfo, EmailExhaustedError, EmailLimitReachedError, ErrorCode, type ErrorHandler, type ErrorInfo, ForbiddenError, type GateClient, type GateModelCall, type GateOutcome, type GateRecordFailure, type GateReply, type GateResult, type GetTextsOptions, type Group, GroupDeletedError, type GroupDetail, type GroupInvitation, type GroupInvitePolicy, type GroupInviteRule, type GroupMember, type GroupRole, type GroupSettings, type GroupSystemEvent, type GroupSystemEventV1, HandleRequiredError, type HttpMethod, type HttpRequestOptions, type HttpResponse, HttpTransport, type HttpTransportOptions, INBOX_TRAY_DEFAULT_LIMIT, INBOX_TRAY_MAX_LIMIT, INBOX_WAIT_MAX_MS, type InboxCard, type InboxCardGroup, type InboxCardPreview, type InboxCardRelationship, type InboxMode, type InboxResource, type InboxTray, type InboxTrayOptions, type KnownReplyDecisionCategory, MAX_ATTACHMENT_SIZE, type MarkConversationReadRequest, type MarkConversationReadResult, type Message, type MessageContent, type MessageHandler, type MessageStatus, type MessageType, type MuteEntry, type MuteTargetKind, NotFoundError, type PausedByOwner, type Presence, type PresenceBatchRequest, type PresenceBroadcast, type PresenceStatus, type PresenceUpdate, RateLimitedError, RealtimeClient, type RealtimeOptions, type RealtimeState, RecipientBackloggedError, type RecordReplyDecisionOptions, type RecordReplyDecisionRequest, type RecoverOptions, type RecoverRequest, type RecoverResult, type RegisterRequest, type RenderOptions, type ReplyDecision, type ReplyDecisionCategory, type ReplyDecisionVerdict, type ReportRequest, type RequestHooks, type RequestInfo, type ResponseInfo, RestrictedError, type RetryInfo, type RetryOption, type RetryPolicy, type RunGateOptions, type SendMessageRequest, type SendMessageResult, type SequenceGapHandler, type SequenceGapInfo, ServerError, type ServerEvent, type StateHandler, type StoppedHandler, SuspendedError, type SyncEnvelope, type Texts, type TextsResource, type TextsRuntime, type ToolNamer, UnauthorizedError, type UpdateAgentRequest, type UpdateContactRequest, type UpdateGroupRequest, VERSION, ValidationError, type Verdict, type VerifyRequest, type WakeFrame, type WakeHandler, type WakePayload, type WsMessage, createAgentChatError, gate, isAuthRejectionClose, paginate, parseRetryAfter, renderMessageContext };
|