@xema/omni-protocol 0.1.53 → 0.1.54

package/dist/testing.js

@@ -902,6 +902,10 @@ async function driveOneCall(drive) {
         const declared = capabilities[name];
         return declared !== undefined && !(isRecord(declared) && declared.lockedBy !== undefined);
     };
+    // Media may arrive any time after the accept, before or after the task's own update says
+    // in-progress: the event is the provider's word that the audio should attach, never a reply to
+    // openMedia, so the drive looks for it from the accept rather than from the last update it read.
+    const acceptedAt = drive.events.length;
     // 1. Accept the offer, if it is one.
     if (latestTask().phase === "pending") {
         if (await send({ type: drive.channel === "voice" ? "answer" : "accept" }) === undefined)
@@ -929,10 +933,10 @@ async function driveOneCall(drive) {
             const started = await waitFor("task-media-started for the driven task", envelope => {
                 const event = envelope.event;
                 return event.type === "task-media-started" && event.taskId === taskId ? event : undefined;
-            }, cursor);
+            }, acceptedAt);
             if (started === undefined)
                 return found;
-            cursor = started.at;
+            cursor = Math.max(cursor, started.at);
         }
         const opened = await drive.connection.openMedia?.({ taskId, localAudio: drive.localAudio });
         found.push(...validateResult(opened, "openMedia", "drive.openMedia"));
@@ -972,7 +976,10 @@ async function driveOneCall(drive) {
         }
     }
     // 6. Complete, where the agent completes; otherwise the provider does, and the drive waits for it.
-    if (latestTask().completionMode === "agent-command" && latestTask().phase === "completing") {
+    // A conversation has no media to end and no completing phase to wait for: a chat or an email,
+    // and a voice task offering no end-call, is completed from where it stands.
+    const completable = latestTask().phase === "completing" || latestTask().phase === "in-progress" || latestTask().phase === "paused";
+    if (latestTask().completionMode === "agent-command" && completable) {
         const command = { type: "complete" };
         const dispositions = isRecord(latestTask().capabilities) ? latestTask().capabilities.dispositions : undefined;
         if (isRecord(dispositions) && dispositions.required === true && Array.isArray(dispositions.codes) && isRecord(dispositions.codes[0])) {

package/guide.md

@@ -4127,6 +4127,9 @@ partial patch.
 The provider's word that the task's audio should now attach. Omni calls `openMedia` on it — and on
 a task carried with `media: "started"`, which is how a reconnect snapshot reattaches audio an
 earlier event brought — and renders the call as live from that word, never from its own senses. It
+precedes `openMedia` and is never a reply to it: a provider whose media state comes from the
+platform, a station going in use the moment a call is answered, sends it then, before any host has
+opened anything, and `openMedia` has its own answer for what the host did. It
 names a task whose work has begun, and it alternates with `task-media-ended`: media that never
 started cannot end, so a live call whose provider says nothing about its audio is a provider in
 breach, not a state a desk fills in from its own devices.
@@ -4338,8 +4341,14 @@ complete it with a disposition where the agent completes -- and holds every step
 host holds a provider to. Each command is validated against the task as published
 (`drive.command.*`), each answer for its method, a refusal of a control the task offered is a
 violation (`drive.command.failed`), and an event the provider owes and never sends is one too
-(`drive.timeout`, after `driveTimeoutMs`, 5000 by default). The drive stops where the task offers
-no way on and says nothing about what it could not reach. It is off by default because it issues
+(`drive.timeout`, after `driveTimeoutMs`, 5000 by default). A task the agent completes is
+completed from wherever it stands once the drive has nothing left to do on it -- from `completing`
+after an `end-call`, or from `in-progress` where there is no call to end, which is every chat and
+email and a voice task offering no `endCall` -- so a conversation reaches its end as a call does.
+The drive stops where the task offers no way on and says nothing about what it could not reach. A
+softphone adapter written for a browser needs its media APIs supplied by whatever runs the
+harness: the drive opens media outside a browser, and a provider that quietly stopped carrying audio
+where `AudioContext` was missing would be lying about the one thing the channel is for. It is off by default because it issues
 commands against whatever platform the adapter is connected to: turn it on against a test backend.
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xema/omni-protocol",
-  "version": "0.1.53",
+  "version": "0.1.54",
   "description": "The Omni protocol: the contract every provider adapter implements",
   "type": "module",
   "license": "MIT",