@xema/omni-protocol 0.1.129 → 0.1.130
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/GLOSSARY.md +2 -2
- package/README.md +6 -8
- package/dist/index.d.ts +138 -87
- package/dist/index.js +24 -9
- package/dist/testing.d.ts +14 -14
- package/dist/testing.js +79 -82
- package/dist/validation.d.ts +23 -23
- package/dist/validation.js +174 -121
- package/guide/agent.md +23 -23
- package/guide/breaks.md +1 -1
- package/guide/lead.md +34 -17
- package/guide/phone.md +22 -22
- package/guide/queue.md +7 -7
- package/guide/voice.md +64 -54
- package/guide.md +163 -143
- package/package.json +1 -1
package/guide/agent.md
CHANGED
|
@@ -14,7 +14,7 @@ capacity is stated, and needs no other word for it.
|
|
|
14
14
|
or when the agent presses Ready. A successful connection, a healthy provider, or the absence of a
|
|
15
15
|
break does not imply readiness. After that, an agent stops taking work on this provider only by a
|
|
16
16
|
break under `capabilities.breaks`, or by the agent application restating `count: 0` -- which is how
|
|
17
|
-
a forced break on another provider reaches this one; a
|
|
17
|
+
a forced break on another provider reaches this one; a user whose capabilities include no breaks has no
|
|
18
18
|
not-ready of its own, and `count: 0` is the agent application's division of capacity, not the
|
|
19
19
|
agent's choice.
|
|
20
20
|
|
|
@@ -35,7 +35,7 @@ intent.
|
|
|
35
35
|
|
|
36
36
|
### Acceptance modes
|
|
37
37
|
|
|
38
|
-
During
|
|
38
|
+
During sign-in, Omni sends the agent's `autoAcceptTasks` value to the provider. When it is `true`, the
|
|
39
39
|
provider states `acceptance` on each pending task — on the task rather than the offer, so a
|
|
40
40
|
reconnect snapshot says it too and an offer the agent application never received is not accepted on the
|
|
41
41
|
person's behalf for want of a word:
|
|
@@ -131,7 +131,7 @@ required and closed (`event.taskEnded.outcome.cancelled.by`). An offer nobody ac
|
|
|
131
131
|
The provider does not introduce new work as already `in-progress`.
|
|
132
132
|
|
|
133
133
|
A task appears already `in-progress` only in a snapshot taken after a reconnect or a resync,
|
|
134
|
-
reporting work that began earlier in this
|
|
134
|
+
reporting work that began earlier in this session and never stopped. A fresh session has none to
|
|
135
135
|
report: nothing has been assigned yet, and work the agent was working elsewhere is not carried
|
|
136
136
|
into a new session.
|
|
137
137
|
|
|
@@ -169,7 +169,7 @@ time. Runtime conformance checks also require the task channel to match its prov
|
|
|
169
169
|
| `wrapEndsInSeconds` | In `completing`, wherever `wrapAllowance` is stated: how much of the wrap is left, in whole seconds from this publication, restated on every publication that carries it (`task.completing.wrapEndsInSeconds`, `.required`, `.unexpected`). A reloaded agent computer and a lead's screen count down the same number. See **Completion timing**. |
|
|
170
170
|
| `attributes` | Optional ordered, typed `TaskAttribute` entries with keys unique within the task. Each contact or timestamp is a separate array item; new attribute shapes require new union members. |
|
|
171
171
|
| `history` | The call record: `steps` — the ordered interaction history of this open task, one entry per occurrence, oldest first — and what they add up to before this agent, `interactionSeconds`, `holdSeconds`, `queueSeconds`, `transfers`, each present when the provider knows it. Live task data restated with the task, not a permanent archive. See **Interaction history**. |
|
|
172
|
-
| `onCall` | Voice only. Who is on the call, or being brought onto it, as the provider states it, replaced whole with the task: `party` is the customer -- carrying a `stage` while being dialled again on the same task, a connect-back with the agent application's `dialId` or a platform's callback without, ringing from the moment the dial is placed and joined on its answered outcome --, `agent` a person by user id, `
|
|
172
|
+
| `onCall` | Voice only. Who is on the call, or being brought onto it, as the provider states it, replaced whole with the task: `party` is the customer -- carrying a `stage` while being dialled again on the same task, a connect-back with the agent application's `dialId` or a platform's callback without, ringing from the moment the dial is placed and joined on its answered outcome --, `agent` a person by user id -- marked `coaching: true` while a lead coaches the agent, heard by the agent alone --, `added` somebody a dial is bringing in, listed from the moment the dial is placed -- with the `contactId` of the contact dialled, a typed number's included, the `dialId` where an agent application placed it, the `stage` reached (`ringing` until answered, `joined` after), and `held: true` on anyone joined and parked. `label` names a destination -- a person, a queue -- not a phrase; the agent application supplies the verb. Present when the provider knows the room, absent when it does not. See **Every dial has an outcome** in `guide/voice.md`. |
|
|
173
173
|
| `leadAssist` | Voice only. Present from the agent's request for a lead until the lead leaves or the request ends: `requested` while nobody has joined, `joined` with the lead's `leadId` once somebody has. See **Lead assist** in `guide/lead.md`. |
|
|
174
174
|
| `takenOver` | Voice only, on a task that reached this agent by a lead's take-over: which member the call was taken from, and when. It is an ordinary assignment with the call's history, offered whatever break the lead is on and counted against their capacity like any other call. See **Lead assist** in `guide/lead.md`. |
|
|
175
175
|
|
|
@@ -231,7 +231,7 @@ already safe, since its outcome is placed by the agent application's own `dialId
|
|
|
231
231
|
assignment earns its place is everything the agent application does not mint --
|
|
232
232
|
`task-audio-started`, `task-audio-ended`, `task-ended`, a `recordStep` naming a task -- any of which
|
|
233
233
|
would otherwise find the next customer under a reused handle and act on them. A minted id is part
|
|
234
|
-
of the task the adapter keeps, not a field held in memory beside it: it lives in the
|
|
234
|
+
of the task the adapter keeps, not a field held in memory beside it: it lives in the session's
|
|
235
235
|
`store` with the task, or is derived from a platform handle that itself never reuses, so a rebuilt
|
|
236
236
|
adapter comes back with the same assignment on the same task, or every late event it was minted to
|
|
237
237
|
catch mismatches and the second adapter's snapshot no longer carries the task (`test.reload.snapshot`).
|
|
@@ -380,7 +380,7 @@ Migration from the earlier spellings:
|
|
|
380
380
|
| a wrap the agent computer timed from an event's receipt | `Task.wrapEndsInSeconds` in `completing`, restated (`task.completing.wrapEndsInSeconds`, `.required`, `.unexpected`) |
|
|
381
381
|
| MemberTask.capabilities, capabilitySource, browsers | gone: the workspace never travels to a lead (`team.member.task.workspace`); the record and the completion terms do |
|
|
382
382
|
| a member republished on a hold, a mute, a take-over | on every publication of the member's task to the member |
|
|
383
|
-
| two clients on one
|
|
383
|
+
| two clients on one session | the later wins; the first is ended with `recovery: "displaced"` |
|
|
384
384
|
| the phone unspoken | `PhoneState` -- the device, its mute, its channels -- on `Snapshot.phone`, `phone-updated` and `TeamMember.phone`, from a manifest declaring `phoneStatus` (`snapshot.phone.required`, `.unexpected`, `phone.*`, `phone.channel.*`, `event.phone.capability`) |
|
|
385
385
|
| the agent's readiness for the next call read into setCapacity | the agent's own queue: `capabilities.nextCall`, `requestNextCall`/`cancelNextCall`/`releaseLinedUp`, `Snapshot.nextCall` and `linedUp`, the `next-call` and `lined-up` events (`snapshot.nextCall.idle`, `nextCall.*`, `linedUp.*`) |
|
|
386
386
|
| a harness that exercised an adapter, drove a call and evaluated rules | the harness reads as a test: `testAdapter`, `withCall`, `timeoutMs`, `notTested`, `rulesTested`, rules `test.*` (`test.timeout`, `test.offer.expired`, `test.preview.deadline`, ...) |
|
|
@@ -389,9 +389,9 @@ Migration from the earlier spellings:
|
|
|
389
389
|
| a refusal on hold under `omni.command-not-permitted` | `omni.on-hold` |
|
|
390
390
|
| outbound work's terms reported as `queue` | `dialer`: the dialer that declared the task chose its capabilities |
|
|
391
391
|
| an `end-call` while the caller was on hold | refused: a `paused` task is resumed first (`command.endCall.held`), the agent computer shows End call disabled on hold, the provider answers `failed`, and the test names an adapter that ends from hold (`test.command.held`); `terminate-call` is not gated, it ends the caller's channel too |
|
|
392
|
-
| the handset spelled by its place on a desk | `hardphone`, on the manifest's `phones` and the
|
|
392
|
+
| the handset spelled by its place on a desk | `hardphone`, on the manifest's `phones` and the session's `phone`; the former spelling is refused |
|
|
393
393
|
| the desk | the agent computer, in the guide's prose |
|
|
394
|
-
| the agent application's Mute on hold | unavailable while the task is `paused`, promised at
|
|
394
|
+
| the agent application's Mute on hold | unavailable while the task is `paused`, promised at sign-in by a softphone session's agent application (`host.guarantees.muteUnavailableOnHold`, required there and refused of a hardphone session); a host mute beginning on a paused task is refused (`historyReport.muted.held`) and the test names an adapter that records one (`test.recordStep.held`) |
|
|
395
395
|
| a session ended from outside the agent computer, reported as `expired` | `terminated`, with `by` (a person or `provider`) and a reason never retryable; `signed-out` is only the agent's own Sign out here; an ended session's secrets are deleted before the ending is published (`authentication.secrets.retained`), kept only for an `expired` whose failure is retryable; the agent application clears the store after, and resumes no stored token |
|
|
396
396
|
|
|
397
397
|
Update producers, consumers, saved task snapshots, and validation-rule assertions together.
|
|
@@ -431,7 +431,7 @@ something else, which will arrive under its own name and must not be folded in h
|
|
|
431
431
|
|
|
432
432
|
It rides in the snapshot and is replaced whole like everything else there.
|
|
433
433
|
|
|
434
|
-
Steps are `arrived`, `self-service`, `queued`, `offered`, `answered`, `held`, `muted`, `transferred`, `
|
|
434
|
+
Steps are `arrived`, `self-service`, `queued`, `offered`, `answered`, `held`, `muted`, `transferred`, `added`,
|
|
435
435
|
`unanswered`, `callback-requested`, and each is defined on `TaskHistoryStep`.
|
|
436
436
|
|
|
437
437
|
**The record starts where the call started.** `arrived` is the instant the call reached the
|
|
@@ -507,7 +507,7 @@ may add to them; it never has fewer, and never drops the record while the task i
|
|
|
507
507
|
stated to the agent application and then withdrawn without an event is a record contradicting itself, exactly
|
|
508
508
|
as a task that lost the terms it had read would be, and the stream refuses it the same way
|
|
509
509
|
(`stream.taskUpdated.history`, `stream.snapshot.history`). A provider whose
|
|
510
|
-
platform cannot hold a leg the agent application reported keeps it in the
|
|
510
|
+
platform cannot hold a leg the agent application reported keeps it in the session's `store` for the life of the
|
|
511
511
|
task, so a reload of the agent application restates the same record; the entry is keyed by `step` and `at`, so
|
|
512
512
|
a running hold restated with its final `seconds` is the same entry.
|
|
513
513
|
|
|
@@ -543,8 +543,8 @@ account of a period the agent could not be heard. Each `muted` entry carries `mu
|
|
|
543
543
|
reported it: `host` for the agent's own Mute, `station` for a headset or system mute the agent application
|
|
544
544
|
observed. No other step has it (`task.history.mutedBy`, `.mutedBy.unexpected`).
|
|
545
545
|
|
|
546
|
-
**A step that dialled says which dial and where.** `
|
|
547
|
-
and `transferred` a hand-over on the platform's own routing, so the entry carries the `
|
|
546
|
+
**A step that dialled says which dial and where.** `added` and `unanswered` each end a dial,
|
|
547
|
+
and `transferred` a hand-over on the platform's own routing, so the entry carries the `contactId`
|
|
548
548
|
it went to and, where an agent application placed the dial, the `dialId` the agent application minted; no other step dialled, and either field on one is refused
|
|
549
549
|
(`task.history.dialId.unexpected`). This is how a dial made before a take-over is placeable
|
|
550
550
|
by whoever holds the task now: a `dial-outcome` naming a `dialId` the agent application never minted is looked
|
|
@@ -560,7 +560,7 @@ Four rules a provider has to keep:
|
|
|
560
560
|
- **Omit `seconds` while it is unknown. Never send `0`.** A leg still talking is not a zero-second
|
|
561
561
|
conversation, and on live data that is the ordinary case rather than an edge. A zero is rejected.
|
|
562
562
|
- **`by` is a bare `UserId`, and not necessarily an agent.** A lead or a manager takes part
|
|
563
|
-
during an interaction too — a call taken over, a call
|
|
563
|
+
during an interaction too — a call taken over, someone added to a call — so the field names whoever it was,
|
|
564
564
|
from the same directory `ForcedBreak.by` names a lead from. It comes from this provider's own directory, the same
|
|
565
565
|
namespace as `AuthenticationState.identity.id` and the team member list, so entries pair
|
|
566
566
|
within a provider and never across one.
|
|
@@ -625,7 +625,7 @@ leg, when it began and when it ended, and `validateHistoryReport(report, path, m
|
|
|
625
625
|
a running one it was never asked for (`historyReport.running.unexpected`). What a provider that
|
|
626
626
|
did ask for them forwards upstream, and how often, is its own business. The step appears in
|
|
627
627
|
`history` when the *provider* publishes it: Omni never writes the record itself.
|
|
628
|
-
`recordStep` is required of every softphone
|
|
628
|
+
`recordStep` is required of every softphone session's connection, since every call on a softphone
|
|
629
629
|
can be muted by the agent application, and answers `recorded` with the canonical history `at`. A `muted` report says whose the silence was,
|
|
630
630
|
`mutedBy: "host"` or `"station"`, and no other report has the word (`historyReport.mutedBy`,
|
|
631
631
|
`.mutedBy.unexpected`). On a hardphone the microphone is the phone's:
|
|
@@ -775,7 +775,7 @@ Task capabilities belong to each `Task`. If `hold` is omitted on one task, Omni
|
|
|
775
775
|
must not show or issue hold for that task even if another task from the same provider supports it.
|
|
776
776
|
|
|
777
777
|
**A capability is a property of the task, and of nothing the task names.** A provider derives it
|
|
778
|
-
from no other source -- not the queue the task came from, not the
|
|
778
|
+
from no other source -- not the queue the task came from, not the session, not its own configuration
|
|
779
779
|
-- because each of those answers a question about this task from somewhere that does not know
|
|
780
780
|
about this task, and a client with two sources and a rule for choosing between them is the shape
|
|
781
781
|
that produces two consumers disagreeing about one fact. The task is the one source, and the
|
|
@@ -897,7 +897,7 @@ See **Which commands need a capability**.
|
|
|
897
897
|
|
|
898
898
|
Two capabilities accept an object when the provider wants Omni to render real choices. For
|
|
899
899
|
`outcomes`, `true` remains valid and means "offer the control with nothing published"; the one
|
|
900
|
-
directory control, `
|
|
900
|
+
directory control, `addToCall`, carries its directory or is refused, since once nothing is typed
|
|
901
901
|
the directory is the control.
|
|
902
902
|
|
|
903
903
|
#### `outcomes`
|
|
@@ -1033,7 +1033,7 @@ capability's `notes` setting. A task publishing no codes still receives `complet
|
|
|
1033
1033
|
### Where a command executes
|
|
1034
1034
|
|
|
1035
1035
|
Every command reaches the provider through `execute`, with no branch at the call site, and every
|
|
1036
|
-
command asks the provider to **perform** something: `hold`, `
|
|
1036
|
+
command asks the provider to **perform** something: `hold`, `addToCall`, `schedule`, `end-call`,
|
|
1037
1037
|
Provider-targeted `recording` commands and the rest act on the platform's own call leg, its bridge, or its record of the
|
|
1038
1038
|
task. Nothing has happened until the provider applies them, and `failed` means nothing happened.
|
|
1039
1039
|
|
|
@@ -1057,19 +1057,19 @@ declared:
|
|
|
1057
1057
|
| `answer`, `accept` | Nothing. A task that was offered can be accepted, or offering it meant nothing. |
|
|
1058
1058
|
| `end-call` | The `endCall` capability: ends my part, the caller continues. Never from hold: a `paused` task is resumed first (`command.endCall.held`), or the caller is left in the hold. |
|
|
1059
1059
|
| `terminate-call` | The `terminateCall` capability: ends the whole call, every channel on it. |
|
|
1060
|
-
| `
|
|
1060
|
+
| `addToCall` with `action: "remove"` | The `addToCall` capability, and somebody else on the call: a remove that would leave the agent alone is `end-call`, and a provider answers it `failed`. |
|
|
1061
1061
|
| `decline` | The `decline` capability on any channel, **and** Omni local policy permitting it. One word for refusing an offer, whatever the channel. |
|
|
1062
1062
|
| `dial` | The `preview` phase. A record put in front of an agent is there to be called, so the phase is the gate and there is no capability. It is a dial, with a `dialId` and a `dial-outcome`. |
|
|
1063
1063
|
| `complete` | A wrap to cut short: any task but a `provider-automatic` one with `wrapAllowance: 0`, under either completion mode (`command.complete.wrapAllowance`). The `outcomes` capability decides whether a code travels with the command, never whether the command exists — a task Omni cannot complete never ends. What travels is what the capability published: a code from its list where it has one (`command.complete.outcome.unknown`), a code at all where it requires one (`.outcome.required`), notes as it said (`.notes.required`, `.notes.unexpected`), and neither where the task declares no outcomes (`.outcome.unexpected`). |
|
|
1064
1064
|
| `connect-back` | The `connectBack` capability **and** the `completing` phase. It exists to reach the party again after the call, so it has no meaning while the call is up. |
|
|
1065
1065
|
| `schedule` | The `schedule` capability, on any channel, in `in-progress`, `paused` or `completing`: a follow-up is promised on the call and written up in wrap alike. The manifest declares `calendar` for it to land on. |
|
|
1066
1066
|
| `lead-assist` with `action: "request"` or `"cancel"` | The `leadAssist` capability. `cancel` needs a request standing -- `Task.leadAssist` with `stage: "requested"`. |
|
|
1067
|
-
| `
|
|
1067
|
+
| `addToCall` with `action: "add"` | Its capability, and a `contactId` from the provider's contacts, or a typed `number` where the capability says `any-number` (`command.addToCall.number.contactsOnly`), never both (`command.addToCall.number.both`). |
|
|
1068
1068
|
| `custom` | A control the task published under `capabilities.custom`, by its `id` (`command.capability.custom`), carrying a non-empty string for each `required` prompt field and strings for any optional fields supplied (`command.custom.prompt`). A toggle carries its target `on` boolean (`command.custom.on`). |
|
|
1069
1069
|
| Everything else | Its own named capability. |
|
|
1070
1070
|
|
|
1071
1071
|
**A control on the contact belongs to the interaction phases**, `in-progress` and `paused`:
|
|
1072
|
-
`hold`, `resume` and `pause`, `end-call` and `terminate-call`, every `
|
|
1072
|
+
`hold`, `resume` and `pause`, `end-call` and `terminate-call`, every `addToCall` action, and
|
|
1073
1073
|
every `lead-assist` action; `schedule` alone reaches into `completing`, and `end-call` alone stops
|
|
1074
1074
|
short of `paused` (`command.endCall.held`), since ending my part from hold leaves the caller in it. These controls act within this agent's current interaction.
|
|
1075
1075
|
In `completing`, that interaction has ended and its wrap work remains. The caller may still be in
|
|
@@ -1136,10 +1136,10 @@ react rather than only display the message:
|
|
|
1136
1136
|
| Code | Meaning |
|
|
1137
1137
|
| --- | --- |
|
|
1138
1138
|
| `omni.not-authenticated` | The provider session is no longer usable. The adapter has published `expired` at or before this answer — the state is what Omni surfaces reauthentication from; the code says why this action failed, and is never the only signal. |
|
|
1139
|
-
| `omni.capability-not-enabled` | The action targets a capability this task, manifest, or
|
|
1139
|
+
| `omni.capability-not-enabled` | The action targets a capability this task, manifest, or session did not declare — including a lead command from a session whose `capabilities` no longer carry it. |
|
|
1140
1140
|
| `omni.assignment-not-found` | The assignment named is not one the provider holds, typically after the task already ended. |
|
|
1141
|
-
| `omni.phone-not-permitted` | The agent application declared a `phone` the platform does not permit for this agent -- a softphone for an agent configured for a hardphone, or the reverse. The
|
|
1142
|
-
| `omni.destination-not-permitted` | The dialled number, or the `
|
|
1141
|
+
| `omni.phone-not-permitted` | The agent application declared a `phone` the platform does not permit for this agent -- a softphone for an agent configured for a hardphone, or the reverse. The session is refused at authentication, and the provider never reconfigures the agent to make the declaration true. See **How the agent hears the call** in `guide/phone.md`. |
|
|
1142
|
+
| `omni.destination-not-permitted` | The dialled number, or the `contactId` named, is not one the provider offers this agent. |
|
|
1143
1143
|
| `omni.rate-limited` | The action was throttled. Pair with `retryAfterMs`. |
|
|
1144
1144
|
| `omni.unavailable` | The provider is temporarily unable to serve the action, including any command sent while `transport-status` is not `active`. |
|
|
1145
1145
|
| `omni.break-already-committed` | Cancellation lost the commit/cancel race; Omni must finish commit recovery. |
|
package/guide/breaks.md
CHANGED
|
@@ -168,7 +168,7 @@ lists show as `elsewhere`. Nobody on those providers can deny it, and the agent
|
|
|
168
168
|
because there is nothing to cancel: a break request on them would be the agent's own to withdraw
|
|
169
169
|
and a lead's to refuse, and a forced break is neither. When the forcing provider ends the forced
|
|
170
170
|
break and the agent resumes there, the agent application restates its capacity on the rest. A
|
|
171
|
-
provider whose
|
|
171
|
+
provider whose session is not usable is left alone, as a break attempt leaves it;
|
|
172
172
|
`assertForcedBreakStopsTheRest` holds an agent application to this set. **The provider keeps its
|
|
173
173
|
shift totals true.** A member held elsewhere is one the provider sees -- `elsewhere` is a state it
|
|
174
174
|
publishes -- and the day's `shift` is its own account of the day, so the time the agent was
|
package/guide/lead.md
CHANGED
|
@@ -5,9 +5,9 @@ The lead's own surface: the team member list, the lead's commands, lead assist,
|
|
|
5
5
|
## Team leads
|
|
6
6
|
|
|
7
7
|
The team feature is the lead's own surface, beside the agent's and never mixed with it. The
|
|
8
|
-
|
|
8
|
+
session's `lead` capabilities turn it on in the agent application; the lead retrieves their members and
|
|
9
9
|
sees, for each, their assignments as they stand and the full history of each, and acts on them
|
|
10
|
-
with the
|
|
10
|
+
with the lead capabilities the session holds. Nothing the lead does here is a task on their agent computer. A lead
|
|
11
11
|
who also takes calls is an agent like any other on the agent side, and a lead who does not want
|
|
12
12
|
the agent role for now places themself on a break of a working kind and keeps the team feature on.
|
|
13
13
|
|
|
@@ -20,7 +20,7 @@ computes nothing. See **`team-updated`** in `guide.md` and its companions.
|
|
|
20
20
|
|
|
21
21
|
| Field | Contract |
|
|
22
22
|
| --- | --- |
|
|
23
|
-
| `members` | Every member of this lead's team, whatever their state, each with their open tasks. `[]` says the lead has a team with nobody in it; omitting the team member list says something else entirely — see **The
|
|
23
|
+
| `members` | Every member of this lead's team, whatever their state, each with their open tasks. `[]` says the lead has a team with nobody in it; omitting the team member list says something else entirely — see **The session is the permission** below. |
|
|
24
24
|
| `policies` | The team's policy per capability as it stands — the setting, who set it, and `lockedBy` where a level above the team made it theirs to keep. Present where the provider offers policy control; absent where it does not. See **Who decides what an agent may do** in `guide.md`. |
|
|
25
25
|
|
|
26
26
|
| `TeamMember` field | Contract |
|
|
@@ -30,7 +30,7 @@ computes nothing. See **`team-updated`** in `guide.md` and its companions.
|
|
|
30
30
|
| `since` | Optional. When the current `availability` began — not when they signed in, and not when the team member list was read. |
|
|
31
31
|
| `break` | Present only while the member has an outstanding break request. See **A member waiting for a break**. |
|
|
32
32
|
| `tasks` | The member's open tasks as `MemberTask`s: the same task the member's computer holds, less the workspace. The assignment, title, task type, phase, party, room, audio and completion terms -- `completionMode`, `wrapAllowance`, `wrapEndsInSeconds` -- are what the lead reads, and the task's record -- `history`, steps and totals -- travels whole, exactly as the member's computer holds it, so the lead's screen and the member's show the same record. The workspace -- `capabilities`, `capabilitySource`, `browsers` and their URLs -- is the member's computer's alone and never travels (`team.member.task.workspace`). The party's number and email are shown to leads or locked as the provider decides for leads, apart from what it decides for the member -- see **What the queue locks is locked on the whole task**. `[]` when the member holds none; omitted only where the provider cannot see them. |
|
|
33
|
-
| `listening` | Every lead on this member's call — listening, coaching or joined — published to every lead alike: each entry names the lead by `leadId`, which of the member's calls by `assignmentId`, the `mode` they are heard in, and since when. The entry naming the signed-in lead is what their own audio opens on. Absent while nobody is on the call, never `[]` (`team.member.listening.*`); a lead is on one member's call at a time (`team.listening.single`), and a lead who is heard is also in the task's `onCall` (`team.member.listening.heard`). |
|
|
33
|
+
| `listening` | Every lead on this member's call — listening, coaching or joined — published to every lead alike: each entry names the lead by `leadId`, which of the member's calls by `assignmentId`, the `mode` they are heard in, and since when. The entry naming the signed-in lead is what their own audio opens on. Absent while nobody is on the call, never `[]` (`team.member.listening.*`); a lead is on one member's call at a time (`team.listening.single`), and a lead who is heard is also in the task's `onCall`: marked `coaching` where the member alone hears them (`team.member.listening.coaching`), unmarked once heard by everyone (`team.member.listening.heard`), and absent while listening in silence (`team.member.listening.silent`). |
|
|
34
34
|
| `request` | Present while the member is asking a lead to join one of their calls: which assignment, the note they wrote, since when. The call named is one their `tasks` carry (`team.member.request.assignment`). Absent when they are not asking. See **Lead assist**. |
|
|
35
35
|
| `nextCall`, `linedUp` | The member's own queue as their own snapshot carries it: their standing ask for the next call, and the call lined up for them. See **The agent's own queue** in `guide/queue.md`. |
|
|
36
36
|
| `phone` | The member's phone as the platform sees it: the same `PhoneState` the member's own snapshot carries, so a lead sees a hardphone that is down, or a call on it that is no task, as the member does. Present where the provider declares `phoneStatus`. See **The phone's own view** in `guide/phone.md`. |
|
|
@@ -80,13 +80,15 @@ knows when the state actually began. It times the current `availability`, so it
|
|
|
80
80
|
that value does. And it is counted from the provider's clock, never the screen's, so a provider
|
|
81
81
|
that publishes it declares `timeCheck` -- see **Every screen counts from the provider's clock** in `guide.md`.
|
|
82
82
|
|
|
83
|
-
**The
|
|
84
|
-
`
|
|
83
|
+
**The user's capabilities are the permission.** A team member list goes to a user whose capabilities
|
|
84
|
+
include `lead`, once the team feature is on, and to nobody else. Omni never decides who
|
|
85
85
|
leads a team: the provider said so at sign-in, and the team member list agrees with it — owed,
|
|
86
86
|
`members: []` included, once a lead has switched the feature on; absent for everybody else, which
|
|
87
87
|
is the correct rendering for an agent who leads nobody (`team.required`, `team.unentitled`). What
|
|
88
|
-
the lead may do with it
|
|
89
|
-
the
|
|
88
|
+
the lead may do with it is the lead capabilities the session holds, stated by the provider with the
|
|
89
|
+
rest of the session's capabilities and current as of the latest: each lead command needs its own
|
|
90
|
+
(`team.command.notGranted`), and the agent application shows a lead only the controls they hold.
|
|
91
|
+
Switching the team feature and leaving a call are every lead's.
|
|
90
92
|
|
|
91
93
|
**The lead switches the feature on and off, and the provider is told.** A lead may work as an
|
|
92
94
|
agent alone, as agent and lead, or as lead alone, and moves between them on the fly. The
|
|
@@ -99,7 +101,7 @@ assignments only from the list.
|
|
|
99
101
|
**The provider assumes nothing.** The switch is not remembered across connections: the agent
|
|
100
102
|
application sends `lead-features` on every connect, after it has stated capacity, and until it has
|
|
101
103
|
the provider treats the feature as off. The connect snapshot therefore carries no team, whatever
|
|
102
|
-
the
|
|
104
|
+
the user's capabilities include; the whole team arrives on `team-updated` once the switch is on, and every
|
|
103
105
|
snapshot after that carries it. A conformance run switches the feature on for a lead and holds the
|
|
104
106
|
provider to that first `team-updated` (`team.required`); a team on the connect snapshot is the
|
|
105
107
|
provider assuming (`team.unexpected`).
|
|
@@ -239,7 +241,8 @@ history. The three modes determine who hears the lead:
|
|
|
239
241
|
| `coach` | The agent alone. The customer hears nothing. |
|
|
240
242
|
| `join-call` | Everyone on the call. |
|
|
241
243
|
|
|
242
|
-
|
|
244
|
+
Each is a lead capability of its own -- `listen`, `coach`, `joinCall` -- so a centre may let a team
|
|
245
|
+
lead listen and coach while only a floor manager joins or takes over.
|
|
243
246
|
|
|
244
247
|
**There is no team audio.** Audio is the agent's or the lead's, and the lead's audio while
|
|
245
248
|
listening follows the provider's published state exactly as a task's does: the entry naming this
|
|
@@ -292,13 +295,27 @@ channel is free, and a provider answers a `listen` from one whose channel is not
|
|
|
292
295
|
includes a lead on a break: a lead working as lead alone is on a break of a working kind, and
|
|
293
296
|
listens through it.
|
|
294
297
|
|
|
295
|
-
**A silent
|
|
296
|
-
no trace of the lead: not on `onCall`, not in the record
|
|
297
|
-
|
|
298
|
+
**A lead who is heard is shown; a silent one reaches nobody but the leads.** In `listen` the
|
|
299
|
+
member's task carries no trace of the lead: not on `onCall`, not in the record
|
|
300
|
+
(`team.member.listening.silent`). In `coach` the member hears the lead and the customer does not,
|
|
301
|
+
so the member's task carries the lead on `onCall` as an `agent` marked `coaching: true`, on the
|
|
302
|
+
member's computer and on every lead's copy alike, for as long as the coaching lasts
|
|
303
|
+
(`team.member.listening.coaching`); the record is unchanged, since coaching is shown while it
|
|
304
|
+
happens and is not a step of the call:
|
|
305
|
+
|
|
306
|
+
```ts
|
|
307
|
+
onCall: [
|
|
308
|
+
{ role: "party", since: "2026-10-18T10:00:00Z" },
|
|
309
|
+
{ role: "agent", userId: "A-12", since: "2026-10-18T10:00:04Z" },
|
|
310
|
+
{ role: "agent", userId: "L-9", coaching: true, since: "2026-10-18T10:05:10Z" },
|
|
311
|
+
]
|
|
312
|
+
```
|
|
313
|
+
|
|
314
|
+
In `join-call`, and
|
|
298
315
|
on a `join` answering a request, the lead is heard by everyone and is in the room: the task's
|
|
299
|
-
`onCall` carries them as an `agent` by user id,
|
|
300
|
-
the task alike, and `leave` takes the entry off as it takes the
|
|
301
|
-
(`team.member.listening.heard`).
|
|
316
|
+
`onCall` carries them as an `agent` by user id, no longer marked `coaching`, on the member's
|
|
317
|
+
computer and on every lead's copy of the task alike, and `leave` takes the entry off as it takes the
|
|
318
|
+
channel off (`team.member.listening.heard`).
|
|
302
319
|
|
|
303
320
|
### A member waiting for a break
|
|
304
321
|
|
|
@@ -327,7 +344,7 @@ whole and replaced whole, and a provider that cannot say omits it.
|
|
|
327
344
|
|
|
328
345
|
**An agent is not waiting on one person.** Authority is held by several, everyone who holds it
|
|
329
346
|
sees the request on their own console, and **any one of them settles it**. Omni offers the
|
|
330
|
-
decision to every
|
|
347
|
+
decision to every user whose capabilities include `lead` and who has the team feature on — which is how the provider already
|
|
331
348
|
says who may decide — and does not try to work out whose turn it is.
|
|
332
349
|
|
|
333
350
|
A request needing *more than one* approval is not something this contract describes. There is
|
package/guide/phone.md
CHANGED
|
@@ -12,11 +12,11 @@ chat and email publish none (`event.audio.channel`, `stream.taskAudio.channel`).
|
|
|
12
12
|
|
|
13
13
|
The provider owns signalling and the platform's endpoint configuration. The agent application selects the
|
|
14
14
|
declared phone mode; it does not enumerate or reconfigure the platform's devices. The selected
|
|
15
|
-
mode stays with the
|
|
15
|
+
mode stays with the session rather than being inferred from a snapshot or a device failure.
|
|
16
16
|
|
|
17
17
|
Nor does the audio ever stand in for the task: a task's presence and
|
|
18
18
|
phase follow the provider's reports about the work, and the audio — attaching, moving through a
|
|
19
|
-
hold,
|
|
19
|
+
hold, someone added to the call, a lead joining or a take-over, and ending — is transient beside it. See **A task is
|
|
20
20
|
never its audio** under **Task assignment lifecycle**.
|
|
21
21
|
|
|
22
22
|
### The agent application reports, the adapter decides
|
|
@@ -44,7 +44,7 @@ the permission everywhere else:
|
|
|
44
44
|
| --- | --- |
|
|
45
45
|
| `browserUrlVisibility` | Every task browser's `urlVisibility` is honoured in this agent application's chrome, tab by tab. A provider that would send a caller's number in a URL checks this first and tokenises where the promise is absent. |
|
|
46
46
|
| `personConsent` | A `consent` offer is accepted only by the person's own explicit act, never on their behalf. A provider whose work may only be taken by a human checks this first and does not offer it where the promise is absent. |
|
|
47
|
-
| `muteUnavailableOnHold` | The agent application's Mute is its own control on any call and is never offered while the task is `paused`: a mute standing when a hold begins stands through it, and the agent lifts it after resume. Held to the
|
|
47
|
+
| `muteUnavailableOnHold` | The agent application's Mute is its own control on any call and is never offered while the task is `paused`: a mute standing when a hold begins stands through it, and the agent lifts it after resume. Held to the session's phone at connect: required of a softphone session's agent application, whose microphone it is (`host.guarantee.muteUnavailableOnHold.required`), and refused of a hardphone session's, whose mute is the handset's (`.unexpected`). So an agent application that cannot control its mute fails at sign-in, not on a call. |
|
|
48
48
|
|
|
49
49
|
A guarantee the agent application does not make is an absent key, never `false` — `validateHostGuarantees`
|
|
50
50
|
refuses a false one, as it refuses a name this contract does not list.
|
|
@@ -65,7 +65,7 @@ is the one that knows whether an agent without a microphone, or without a speake
|
|
|
65
65
|
The agent application's own obligations here — asking at connect, never publishing `not-asked` when it does,
|
|
66
66
|
publishing a state and not a flicker — are Omni's tests' to hold. `testAdapter` holds the
|
|
67
67
|
other side: it validates the shape of whatever agent application a test hands the adapter, requires `audio` on
|
|
68
|
-
a softphone
|
|
68
|
+
a softphone session and none elsewhere -- not on a hardphone, not off voice
|
|
69
69
|
(`context.host.audio.required` / `.unexpected`), holds `host.mute` to the same line (`host.mute.required`
|
|
70
70
|
/ `.unexpected`, `host.mute` for a third word) -- and refuses a voice adapter that never asked the
|
|
71
71
|
agent application anything (`connection.host.consulted`), and one that subscribed to nothing will never hear of a
|
|
@@ -108,18 +108,18 @@ a return.
|
|
|
108
108
|
A voice platform can put an agent on a **softphone**, where the call's audio lands in the agent application
|
|
109
109
|
and Omni owns the microphone and the playback, or on a **hardphone**, a handset on the platform's
|
|
110
110
|
switch that the platform rings, where the agent application owns no audio and only shows the call. Which of
|
|
111
|
-
these a platform can do is a fact about the platform, and which one a
|
|
111
|
+
these a platform can do is a fact about the platform, and which one a session is on is a choice the
|
|
112
112
|
agent application makes for that agent -- so the manifest declares and the agent application chooses.
|
|
113
113
|
|
|
114
114
|
```ts
|
|
115
115
|
// Manifest: what the platform can do
|
|
116
116
|
phones: ["softphone", "hardphone"]
|
|
117
|
-
// The agent application, at authentication and again at connect: which one this
|
|
117
|
+
// The agent application, at authentication and again at connect: which one this session is on
|
|
118
118
|
{ phone: "softphone" }
|
|
119
119
|
```
|
|
120
120
|
|
|
121
121
|
A voice manifest lists its `phones` and any other channel lists none (`manifest.phones.required`,
|
|
122
|
-
`manifest.phones.channel`). The agent application's `phone` is required on a voice
|
|
122
|
+
`manifest.phones.channel`). The agent application's `phone` is required on a voice session, absent on any other,
|
|
123
123
|
and one the manifest listed (`context.phone.required`, `.unexpected`, `.unsupported`). Everything
|
|
124
124
|
about audio then follows the phone rather than the channel: on a softphone the agent application reports its
|
|
125
125
|
audio, the adapter implements `openAudio`, and `task-audio-started` is the word to open it; on a
|
|
@@ -132,34 +132,34 @@ of station the agent signed in at, because the person chose it, and nothing else
|
|
|
132
132
|
The provider knows whether that station can carry a call right now -- whether a handset is
|
|
133
133
|
registered -- which an agent application in a browser cannot see. So the agent application's `phone` selects the branch, and
|
|
134
134
|
the provider's own knowledge of the device decides readiness within it. A provider never overrides
|
|
135
|
-
the agent application's declaration from its device record: treating a hardphone
|
|
135
|
+
the agent application's declaration from its device record: treating a hardphone session as a softphone because
|
|
136
136
|
the handset is momentarily unregistered, and demanding a microphone of it, is the reading this
|
|
137
137
|
sentence exists to refuse. What the provider does when the handset is not registered is what it
|
|
138
138
|
does for any station that cannot take a call -- hold the agent not-ready and say why.
|
|
139
139
|
|
|
140
|
-
**On a hardphone
|
|
140
|
+
**On a hardphone session the agent application never calls `openAudio`.** There is no stream to hand over and
|
|
141
141
|
no audio to attach; an agent application that calls it anyway is in error, and an adapter that receives the call
|
|
142
142
|
answers `unavailable` with a non-retryable failure, since waiting changes nothing about a station
|
|
143
143
|
that is a telephone. The harness requires no `openAudio` of such an adapter and never calls it.
|
|
144
144
|
|
|
145
|
-
**Which handset a hardphone
|
|
145
|
+
**Which handset a hardphone session rings is the platform's configuration for that agent**, and
|
|
146
146
|
this wire never asks the agent for it: an agent application declares `phone` and nothing more. What a platform
|
|
147
147
|
asks on surfaces of its own is its own decision.
|
|
148
148
|
|
|
149
|
-
**A declared phone the platform does not permit for this agent is a
|
|
149
|
+
**A declared phone the platform does not permit for this agent is a session that cannot be
|
|
150
150
|
established.** The manifest says what the platform can do; the agent's record, kept by an
|
|
151
151
|
administrator, says what this agent is configured for, and the two can disagree with the agent application's
|
|
152
152
|
declaration -- a softphone declared for an agent whose record says hardphone. Honouring that
|
|
153
153
|
declaration on a switch that allows one registration per endpoint would evict the handset: the
|
|
154
154
|
agent's phone stops ringing and their calls land in a tab, and nobody is told. So the provider
|
|
155
|
-
refuses the
|
|
155
|
+
refuses the session at authentication, with `omni.phone-not-permitted` and a message the agent application shows
|
|
156
156
|
-- "this agent is configured for a hardphone" -- and refusing is correct, not an override of the
|
|
157
157
|
agent application. It is a refusal, never a negotiation afterwards and never a quiet substitution, and it is
|
|
158
158
|
never retryable: trying again does not reconfigure the agent, and an agent application validating the answer
|
|
159
159
|
(`validateAuthenticationResult`) refuses a phone refusal marked otherwise
|
|
160
160
|
(`authentication.failure.phone.retryable`). And **a
|
|
161
161
|
provider never makes a declared phone true by changing the platform's configuration**: the record
|
|
162
|
-
is the administrator's, and a
|
|
162
|
+
is the administrator's, and a session is not a request to reconfigure an agent.
|
|
163
163
|
|
|
164
164
|
### Opening the audio
|
|
165
165
|
|
|
@@ -190,7 +190,7 @@ carries as `audio.input.localAudio`, and absent while that input is `unavailable
|
|
|
190
190
|
bridges audio without an application-side input may ignore it; one that needs it and finds it absent
|
|
191
191
|
answers `unavailable` with a failure Omni shows the agent.
|
|
192
192
|
|
|
193
|
-
**When to ask is the provider's word, not Omni's guess.** On a softphone
|
|
193
|
+
**When to ask is the provider's word, not Omni's guess.** On a softphone session, Omni opens audio on `task-audio-started`,
|
|
194
194
|
and on a task arriving with `audio: "started"` on a snapshot; it closes on `task-audio-ended` and
|
|
195
195
|
when the task ends. Between those words, nothing Omni's own senses report — a stream that drops, a
|
|
196
196
|
track that ends — moves the task or its audio.
|
|
@@ -218,7 +218,7 @@ agent application sends: the microphone keeps capturing, the party hears silence
|
|
|
218
218
|
changes, and every softphone agent application can do it. A *station* mute silences the microphone itself at
|
|
219
219
|
the operating system: every application on the machine goes quiet, the system shows it, and a
|
|
220
220
|
headset that follows the system follows it. Only a native agent application can do it. `Host.mute` says which
|
|
221
|
-
this agent application does -- `stream` or `station` -- stated on a softphone
|
|
221
|
+
this agent application does -- `stream` or `station` -- stated on a softphone session, where the agent application holds the
|
|
222
222
|
microphone, and absent on a hardphone and off voice (`host.mute.required` / `.unexpected`). A
|
|
223
223
|
browser says `stream`. A native agent application says whichever it does. Nothing on the wire says what kind of
|
|
224
224
|
application the agent application is; a provider reads only what the agent application declared.
|
|
@@ -235,7 +235,7 @@ the endpoint and can clear an operating-system mute. A hardware slider is nobody
|
|
|
235
235
|
**The record carries the same word.** A `muted` interaction leg is a period the agent could not be
|
|
236
236
|
heard, and the record exists so that period is not a hole. **The Mute waits for resume.** On a
|
|
237
237
|
softphone the agent application's own Mute is unavailable while the task is `paused`, as it
|
|
238
|
-
promised at
|
|
238
|
+
promised at sign-in (`muteUnavailableOnHold`): mute then hold is ordinary, and the muted leg runs on
|
|
239
239
|
across the held one; hold then mute is not, and a `muted` leg with `mutedBy: "host"` beginning on a
|
|
240
240
|
paused task is held back by the agent application (`historyReport.muted.held`) and refused by a
|
|
241
241
|
provider that receives one anyway, `failed` with `omni.on-hold`. The test sends one past the validator while the task is held
|
|
@@ -245,7 +245,7 @@ with `mutedBy: "station"`, and stands. The agent application reports every such
|
|
|
245
245
|
through `recordStep` -- its own Mute, and a station mute it observed during a call -- with
|
|
246
246
|
`mutedBy` saying whose the silence was, and the provider writes the word into the entry
|
|
247
247
|
(`task.history.mutedBy`). The report names no agent because the agent application has exactly one, and
|
|
248
|
-
the provider knows who that is: it attributes the leg to the
|
|
248
|
+
the provider knows who that is: it attributes the leg to the session's agent in `by`, a fact it
|
|
249
249
|
holds and not an inference, for a station mute as much as for the agent application's own. An unattributed
|
|
250
250
|
`muted` entry is refused (`task.history.muted.by`); a shared handset's unattributed hold
|
|
251
251
|
is a different claim, and stands. A supervisor reading the record then sees "the agent muted for
|
|
@@ -295,7 +295,7 @@ and `phone-updated`, from a manifest that declares `phoneStatus` (`snapshot.phon
|
|
|
295
295
|
`snapshot.phone.unexpected`, `event.phone.capability`).
|
|
296
296
|
|
|
297
297
|
```ts
|
|
298
|
-
//
|
|
298
|
+
// people added to the call on alloc-42 -- one channel, since the bridge mixes -- with alloc-43 parked
|
|
299
299
|
const busy: PhoneState = { phone: "hardphone", status: "ready", muted: true, channels: [
|
|
300
300
|
{ state: "active", since: "2026-09-12T10:30:04Z", assignmentId: "alloc-42" },
|
|
301
301
|
{ state: "held", since: "2026-09-12T10:35:20Z", assignmentId: "alloc-43" },
|
|
@@ -316,14 +316,14 @@ the other three are the states in which nothing can land, each wanting a differe
|
|
|
316
316
|
| `do-not-disturb` | The agent pressed it on the device. Nothing lands until they clear it; it is not a break, and the provider assigns or not as its platform does. |
|
|
317
317
|
| `off-hook` | The handset is up with no call on it, and no channel is on it. |
|
|
318
318
|
|
|
319
|
-
`phone` is the agent's device for this provider: the one the host chose for the
|
|
319
|
+
`phone` is the agent's device for this provider: the one the host chose for the session at
|
|
320
320
|
connect, from the manifest's phones, as the way the agent hears this provider's calls. A state
|
|
321
|
-
naming the other is the wrong phone (`phone.phone.mismatch`). The phone is the agent's; the
|
|
322
|
-
is the agent's session with the provider, and what belongs to the
|
|
321
|
+
naming the other is the wrong phone (`phone.phone.mismatch`). The phone is the agent's; the session
|
|
322
|
+
is the agent's session with the provider, and what belongs to the session is that choice. `since` is when the status began, counted from the
|
|
323
323
|
provider's clock like every duration off the active call, and omitted rather than invented.
|
|
324
324
|
|
|
325
325
|
**The channels.** The phone has one active audio channel and any number held
|
|
326
|
-
(`phone.channel.active.single`), and a bridge is one channel: a
|
|
326
|
+
(`phone.channel.active.single`), and a bridge is one channel: a call with people added is one entry, and its
|
|
327
327
|
members are on the task's `onCall`, never repeated here. Each channel is `ringing`, `active` or
|
|
328
328
|
`held`, since when, and names the task its call is where it is one. **Where a channel is a task's,
|
|
329
329
|
the two views agree** (`phone.channel.task`): `active` with the task at work and its audio
|
package/guide/queue.md
CHANGED
|
@@ -11,7 +11,7 @@ platform's queue and never instead of it, and the contract carries it in three p
|
|
|
11
11
|
the lined-up call, and the release.
|
|
12
12
|
|
|
13
13
|
```ts
|
|
14
|
-
// the
|
|
14
|
+
// the user's capabilities include it, as they include breaks
|
|
15
15
|
{ status: "authenticated", identity: {...}, capabilities: { breaks: true, nextCall: true } }
|
|
16
16
|
|
|
17
17
|
// 1. The ask. The agent presses Next call during the call or the wrap; the agent computer offers the button
|
|
@@ -92,8 +92,8 @@ carries `nextCall` and `linedUp` as the member's own snapshot does, republished
|
|
|
92
92
|
|
|
93
93
|
Use `validateBreakCommand(method, request, state, context)` from the validation entry point
|
|
94
94
|
before any agent break dispatch. The context supplies current authentication and transport, and
|
|
95
|
-
the manifest's `levels` the
|
|
96
|
-
all four methods require the live
|
|
95
|
+
the manifest's `levels` the session is validated against;
|
|
96
|
+
all four methods require the live session's break capability and active transport. Pass the
|
|
97
97
|
request object only to the request method, and undefined to the other three.
|
|
98
98
|
|
|
99
99
|
| Method | Required current state |
|
|
@@ -105,7 +105,7 @@ request object only to the request method, and undefined to the other three.
|
|
|
105
105
|
|
|
106
106
|
Use `validateTeamCommand(request, context)` before every lead act, its context carrying the manifest's `levels` as the break check's does: the team feature switch, break
|
|
107
107
|
decisions, forcing and ending a forced break, policy, and every act on a member's call. It requires
|
|
108
|
-
the live `lead`
|
|
108
|
+
the live `lead` capability the command needs and active transport, a current team member list for any command naming a
|
|
109
109
|
member, and the target's complete break state for forcing/ending a break. Approve/deny requires an
|
|
110
110
|
awaiting decision; forcing a break uses the target's reason codes; ending a forced break requires a
|
|
111
111
|
forced committed break; join and decline need the member's request on the list; coach, join-call
|
|
@@ -256,7 +256,7 @@ outstanding and offers **Cancel break request**, but does not tell the agent tha
|
|
|
256
256
|
begun.
|
|
257
257
|
|
|
258
258
|
Omni offers the aggregate Break control only when every provider currently holding capacity
|
|
259
|
-
declares `capabilities.breaks` at
|
|
259
|
+
declares `capabilities.breaks` at sign-in. If one cannot be stopped, offering a global break would
|
|
260
260
|
knowingly permit partial availability.
|
|
261
261
|
|
|
262
262
|
Omni coordinates one break attempt as follows:
|
|
@@ -265,7 +265,7 @@ Omni coordinates one break attempt as follows:
|
|
|
265
265
|
currently receive work. A provider joining during the attempt is given no capacity until it
|
|
266
266
|
finishes. A provider whose authentication is `expired` is not one the agent can receive work
|
|
267
267
|
from and is not asked: nothing is asked of it, the break proceeds without it, and when the
|
|
268
|
-
|
|
268
|
+
session is restored it is reconciled from its snapshot as a set-aside provider is, with no
|
|
269
269
|
capacity until then. `refreshing` keeps a provider in — its identity and capabilities remain
|
|
270
270
|
available and work continues. `assertBreakAttemptProviders` holds an agent application to this set.
|
|
271
271
|
2. Enter `requesting-break`. Keep the agent's normal capacity in place throughout this phase.
|
|
@@ -316,7 +316,7 @@ snapshot before anything else, and the snapshot decides:
|
|
|
316
316
|
late behind it, the provider stops an agent who is already stopped; nothing happens, because a
|
|
317
317
|
commit is a state to be in, not an act to be done.
|
|
318
318
|
- `not-requested` — the grant did not survive. Omni makes a new request for that provider alone,
|
|
319
|
-
against an agent who is already on break elsewhere. **A new
|
|
319
|
+
against an agent who is already on break elsewhere. **A new session is this case too**: the grant
|
|
320
320
|
belonged to the old session.
|
|
321
321
|
|
|
322
322
|
The provider must not offer work in the meantime, and the commit is what stops it; Omni gives it
|