xo-harness 0.1.0 → 0.1.1

package/dist/internal/harness/task-supervisor.js

@@ -149,8 +149,14 @@ export class TaskSupervisor {
         const key = taskKey(event.taskId, event.callId);
         if (this.#terminalTasks.has(key))
             return false;
-        await this.#record(event);
         this.#terminalTasks.add(key);
+        try {
+            await this.#record(event);
+        }
+        catch (error) {
+            this.#terminalTasks.delete(key);
+            throw error;
+        }
         await this.#flush();
         if (deliverContext)
             await this.#deliverContext(event, "terminal");

package/dist/internal/harness/tool-runtime.js

@@ -54,15 +54,27 @@ export class ToolRuntime {
     }
     async #settleCompleted(callId, outcome) {
         this.#assertNotTerminal(callId);
-        await this.#record({ type: "tool.completed", callId, outcome });
         this.#terminal.add(callId);
+        try {
+            await this.#record({ type: "tool.completed", callId, outcome });
+        }
+        catch (error) {
+            this.#terminal.delete(callId);
+            throw error;
+        }
         await this.#flush();
         await this.#deliver(callId, outcome);
     }
     async #settleFailure(callId, message) {
         this.#assertNotTerminal(callId);
-        await this.#record({ type: "tool.failed", callId, error: message });
         this.#terminal.add(callId);
+        try {
+            await this.#record({ type: "tool.failed", callId, error: message });
+        }
+        catch (error) {
+            this.#terminal.delete(callId);
+            throw error;
+        }
         await this.#flush();
         await this.#deliver(callId, { type: "failed", error: message });
     }

package/dist/internal/harness/voice-session.d.ts

@@ -5,6 +5,8 @@ import type { ToolRegistry } from "./tools.js";
 export interface CreateVoiceSessionOptions {
     sessionId: string;
     provider: VoiceProvider;
+    /** Cancels provider startup and closes the live session when its owner is revoked. */
+    signal?: AbortSignal;
     store: EventStore;
     tools: ToolRegistry;
     instructions?: string;

package/dist/internal/harness/voice-session.js

@@ -13,6 +13,7 @@ export class VoiceSession {
     #pendingRecords = new Set();
     #tasks;
     #toolRuntime;
+    #detachOwnerAbort;
     #providerPump;
     #closePromise;
     #maxDurationTimer;
@@ -28,7 +29,7 @@ export class VoiceSession {
             flush: () => this.#store.flush(this.id),
             sessionSignal: this.#controller.signal,
             onError: () => {
-                void this.close("storage_error");
+                this.#closeFromInternal("storage_error");
             },
         });
         this.#toolRuntime = new ToolRuntime({
@@ -43,6 +44,10 @@ export class VoiceSession {
         });
     }
     static async create(options) {
+        const existingEvents = await options.store.list(options.sessionId);
+        if (existingEvents.length > 0) {
+            throw new Error(`Session id already exists: ${options.sessionId}`);
+        }
         const startedAt = performance.now();
         const startedEvent = await options.store.append(createUnsequencedEvent(options.sessionId, startedAt, {
             type: "session.started",
@@ -55,7 +60,15 @@ export class VoiceSession {
                 : { outputModalities: [...options.outputModalities] }),
         }));
         await options.store.flush(options.sessionId);
+        if (options.signal?.aborted) {
+            await recordFailedCreation(options.store, options.sessionId, startedAt, "owner_revoked");
+            throw options.signal.reason ?? new Error("Session owner revoked before startup");
+        }
         const providerController = new AbortController();
+        const abortProviderFromOwner = () => providerController.abort(options.signal?.reason ?? "owner_revoked");
+        if (options.signal?.aborted)
+            abortProviderFromOwner();
+        options.signal?.addEventListener("abort", abortProviderFromOwner, { once: true });
         let providerSession;
         try {
             providerSession = await options.provider.createSession({
@@ -67,18 +80,33 @@ export class VoiceSession {
             });
         }
         catch (error) {
+            options.signal?.removeEventListener("abort", abortProviderFromOwner);
             providerController.abort(error);
-            await recordFailedCreation(options.store, options.sessionId, startedAt);
+            await recordFailedCreation(options.store, options.sessionId, startedAt, options.signal?.aborted ? "owner_revoked" : "provider_create_failed");
             throw error;
         }
+        if (options.signal?.aborted) {
+            options.signal.removeEventListener("abort", abortProviderFromOwner);
+            await providerSession.close("owner_revoked").catch(() => undefined);
+            await recordFailedCreation(options.store, options.sessionId, startedAt, "owner_revoked");
+            throw options.signal.reason ?? new Error("Session owner revoked during startup");
+        }
         const session = new VoiceSession(options, providerSession, startedAt, startedEvent);
         session.#controller.signal.addEventListener("abort", () => providerController.abort(session.#controller.signal.reason), {
             once: true,
         });
+        options.signal?.removeEventListener("abort", abortProviderFromOwner);
+        if (options.signal) {
+            const abortSessionFromOwner = () => {
+                session.#closeFromInternal("owner_revoked");
+            };
+            options.signal.addEventListener("abort", abortSessionFromOwner, { once: true });
+            session.#detachOwnerAbort = () => options.signal?.removeEventListener("abort", abortSessionFromOwner);
+        }
         session.#providerPump = session.#pumpProviderEvents();
         if (options.maxDurationMs !== undefined) {
             session.#maxDurationTimer = setTimeout(() => {
-                void session.close("max_duration_reached");
+                session.#closeFromInternal("max_duration_reached");
             }, options.maxDurationMs);
         }
         return session;
@@ -131,7 +159,12 @@ export class VoiceSession {
         this.#closePromise ??= this.#performClose(reason);
         return this.#closePromise;
     }
+    #closeFromInternal(reason) {
+        void this.close(reason).catch(() => undefined);
+    }
     async #performClose(reason) {
+        this.#detachOwnerAbort?.();
+        this.#detachOwnerAbort = undefined;
         if (this.#maxDurationTimer)
             clearTimeout(this.#maxDurationTimer);
         this.#controller.abort(reason);
@@ -198,11 +231,11 @@ export class VoiceSession {
                             recoverable: event.recoverable,
                         });
                         if (!event.recoverable)
-                            void this.close("provider_error");
+                            this.#closeFromInternal("provider_error");
                         break;
                     case "closed":
                         await this.#record({ type: "provider.closed", reason: event.reason });
-                        void this.close("provider_closed");
+                        this.#closeFromInternal("provider_closed");
                         break;
                 }
             }
@@ -221,14 +254,14 @@ export class VoiceSession {
         this.#toolExecutions.add(execution);
         void execution.then(() => this.#toolExecutions.delete(execution), () => {
             this.#toolExecutions.delete(execution);
-            void this.close("storage_error");
+            this.#closeFromInternal("storage_error");
         });
     }
     #trackRecord(record) {
         this.#pendingRecords.add(record);
         void record.then(() => this.#pendingRecords.delete(record), () => {
             this.#pendingRecords.delete(record);
-            void this.close("storage_error");
+            this.#closeFromInternal("storage_error");
         });
     }
     async #record(event) {
@@ -251,11 +284,11 @@ function createUnsequencedEvent(sessionId, startedAt, event) {
         sessionTimeMs: performance.now() - startedAt,
     };
 }
-async function recordFailedCreation(store, sessionId, startedAt) {
+async function recordFailedCreation(store, sessionId, startedAt, reason) {
     try {
         await store.append(createUnsequencedEvent(sessionId, startedAt, {
             type: "session.ended",
-            reason: "provider_create_failed",
+            reason,
         }));
         await store.flush(sessionId);
     }

package/dist/internal/harness/xo.d.ts

@@ -9,6 +9,8 @@ export interface XOOptions {
 }
 export interface StartSessionOptions {
     provider: VoiceProvider;
+    /** Cancels provider startup and closes the live session when its owner is revoked. */
+    signal?: AbortSignal;
     sessionId?: string;
     instructions?: string;
     /** What the model may produce this session; ["text"] disables audio output. Default: audio. */

package/dist/internal/harness/xo.js

@@ -14,6 +14,7 @@ export class XO {
         return VoiceSession.create({
             sessionId: options.sessionId ?? crypto.randomUUID(),
             provider: options.provider,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
             store: this.store,
             tools: this.tools,
             ...(options.instructions === undefined ? {} : { instructions: options.instructions }),

package/dist/internal/storage/jsonl-event-store.js

@@ -28,7 +28,7 @@ export class JsonlEventStore {
         this.#assertSessionId(sessionId);
         return this.#tails.run(sessionId, async () => {
             try {
-                const file = await open(this.#sessionPath(sessionId), "r");
+                const file = await open(this.#sessionPath(sessionId), "r+");
                 try {
                     await file.sync();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xo-harness",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A TypeScript-first agent harness for continuous, fully duplex voice models.",
   "type": "module",
   "sideEffects": [