@forgeax/engine-intelligence 0.1.6 → 0.1.19

package/src/runtime.ts

@@ -108,7 +108,13 @@ export class IntelligenceRuntime implements IntelligenceService {
       terminal: false,
     };
     this.records.set(submission.id, record);
-    const started = this.provider.start(submission, this.createSink(record));
+    let started: Result<void, IntelligenceError>;
+    try {
+      started = this.provider.start(submission, this.createSink(record));
+    } catch (cause) {
+      this.records.delete(submission.id);
+      return err(providerError(this.providerId, cause));
+    }
     if (!started.ok) {
       this.records.delete(submission.id);
       return started;
@@ -142,7 +148,11 @@ export class IntelligenceRuntime implements IntelligenceService {
         }),
       );
     }
-    return this.provider.cancel(activity);
+    try {
+      return this.provider.cancel(activity);
+    } catch (cause) {
+      return err(providerError(this.providerId, cause));
+    }
   }
 
   close(): Promise<void> {
@@ -152,7 +162,11 @@ export class IntelligenceRuntime implements IntelligenceService {
 
   private async performClose(): Promise<void> {
     this.closed = true;
-    await this.provider.close();
+    try {
+      await this.provider.close();
+    } catch {
+      // Disposal is terminal; provider failure must not strand the realm transport.
+    }
     this.records.clear();
   }
 
@@ -195,7 +209,7 @@ export class IntelligenceRuntime implements IntelligenceService {
   private createSink(record: ActivityRecord): ActivitySink {
     return {
       text: (text) => {
-        if (record.terminal || text.length === 0) return;
+        if (this.closed || record.terminal || text.length === 0) return;
         if (record.outputChars + text.length > this.limits.maxOutputChars) {
           this.overflow(record, 'output-chars', this.limits.maxOutputChars);
           return;
@@ -208,7 +222,7 @@ export class IntelligenceRuntime implements IntelligenceService {
         this.push(record, { type: 'text-delta', text });
       },
       complete: (output) => {
-        if (record.terminal) return;
+        if (this.closed || record.terminal) return;
         if (output.length > this.limits.maxOutputChars) {
           this.overflow(record, 'output-chars', this.limits.maxOutputChars);
           return;
@@ -217,13 +231,13 @@ export class IntelligenceRuntime implements IntelligenceService {
         this.push(record, { type: 'completed', session: record.ref.session, output });
       },
       fail: (cause) => {
-        if (record.terminal) return;
+        if (this.closed || record.terminal) return;
         record.terminal = true;
         const error = providerError(this.providerId, cause);
         this.push(record, { type: 'failed', error: intelligenceFailure(error) });
       },
       cancelled: () => {
-        if (record.terminal) return;
+        if (this.closed || record.terminal) return;
         record.terminal = true;
         this.push(record, { type: 'cancelled' });
       },
@@ -243,7 +257,11 @@ export class IntelligenceRuntime implements IntelligenceService {
     });
     if (record.events.length >= this.limits.maxPendingEventsPerActivity) record.events.pop();
     this.push(record, { type: 'failed', error: intelligenceFailure(error) });
-    this.provider.cancel(record.ref.id);
+    try {
+      this.provider.cancel(record.ref.id);
+    } catch {
+      // The overflow terminal already owns the activity outcome.
+    }
   }
 
   private push(

package/src/transport.ts

@@ -52,9 +52,11 @@ export function bindIntelligencePort(
   runtime: IntelligenceRuntime,
 ): IntelligencePortBinding {
   let closed = false;
+  let closeTask: Promise<void> | undefined;
   const listener = (
     event: MessageEvent<IntelligenceHostCommand | IntelligenceRealmMessage>,
   ): void => {
+    if (closed) return;
     const message = event.data;
     if (message.kind === 'intelligence-submit') {
       const accepted = runtime.accept(message.submission);
@@ -69,26 +71,37 @@ export function bindIntelligencePort(
       return;
     }
     if (message.kind === 'intelligence-poll') {
-      port.postMessage({ kind: 'intelligence-events', events: runtime.poll(message.maxEvents) });
+      const events = runtime.poll(message.maxEvents);
+      try {
+        port.postMessage({ kind: 'intelligence-events', events });
+      } catch {
+        // Poll is destructive; a failed response must terminate the Host binding
+        // so the drained events cannot remain attached to a live runtime.
+        void close().catch(() => undefined);
+      }
       return;
     }
     if (message.kind === 'intelligence-cancel') {
       runtime.cancel(message.activityId);
       return;
     }
-    if (message.kind === 'intelligence-close') void close(true);
+    if (message.kind === 'intelligence-close') void close();
   };
-  const close = async (notifyRealm = false): Promise<void> => {
-    if (closed) return;
+  const close = (): Promise<void> => {
+    if (closeTask !== undefined) return closeTask;
     closed = true;
     port.removeEventListener('message', listener);
-    await runtime.close();
-    if (notifyRealm) {
-      port.postMessage({ kind: 'intelligence-closed' });
-      setTimeout(() => port.close(), 0);
-    } else {
+    closeTask = (async () => {
+      await runtime.close();
+      try {
+        port.postMessage({ kind: 'intelligence-closed' });
+      } catch {
+        // A failed terminal notification must not strand the physical transport.
+      }
+      await new Promise<void>((resolve) => setTimeout(resolve, 0));
       port.close();
-    }
+    })();
+    return closeTask;
   };
   port.addEventListener('message', listener);
   port.start?.();
@@ -145,6 +158,7 @@ export class IntelligencePortClient implements IntelligenceService {
   private pollPending = false;
   private closeTask: Promise<void> | undefined;
   private closeResolve: (() => void) | undefined;
+  private transportReleased = false;
 
   constructor(
     readonly providerId: string,
@@ -157,6 +171,7 @@ export class IntelligencePortClient implements IntelligenceService {
     this.createSessionId = options.createSessionId ?? (() => nextPortIdentity('session'));
     this.listener = (event) => {
       const message = event.data;
+      if (this.closed && message.kind !== 'intelligence-closed') return;
       if (message.kind === 'intelligence-events') {
         this.pollPending = false;
         for (const item of message.events) {
@@ -167,19 +182,32 @@ export class IntelligencePortClient implements IntelligenceService {
         this.active.delete(message.activityId);
         this.rejected.set(message.activityId, message);
       } else if (message.kind === 'intelligence-closed') {
-        this.port.removeEventListener('message', this.listener);
-        this.received.length = 0;
-        this.active.clear();
-        this.rejected.clear();
-        this.port.close();
+        this.markClosed();
+        this.releaseTransport();
         this.closeResolve?.();
         this.closeResolve = undefined;
+        this.closeTask ??= Promise.resolve();
       }
     };
     port.addEventListener('message', this.listener);
     port.start?.();
   }
 
+  private markClosed(): void {
+    this.closed = true;
+    this.received.length = 0;
+    this.active.clear();
+    this.rejected.clear();
+    this.pollPending = false;
+  }
+
+  private releaseTransport(): void {
+    if (this.transportReleased) return;
+    this.transportReleased = true;
+    this.port.removeEventListener('message', this.listener);
+    this.port.close();
+  }
+
   submit(request: ActivityRequest): Result<ActivityRef, IntelligenceError> {
     if (this.closed) return err(new IntelligenceError({ code: 'intelligence-closed', detail: {} }));
     if (request.input.length === 0 || request.input.length > this.limits.maxInputChars) {
@@ -220,10 +248,16 @@ export class IntelligencePortClient implements IntelligenceService {
       session: request.session ?? { providerId: this.providerId, id: this.createSessionId() },
     };
     this.active.add(ref.id);
-    this.port.postMessage({
-      kind: 'intelligence-submit',
-      submission: { ...ref, input: request.input },
-    });
+    try {
+      this.port.postMessage({
+        kind: 'intelligence-submit',
+        submission: { ...ref, input: request.input },
+      });
+    } catch {
+      this.markClosed();
+      this.releaseTransport();
+      return err(new IntelligenceError({ code: 'intelligence-closed', detail: {} }));
+    }
     return ok(ref);
   }
 
@@ -243,7 +277,13 @@ export class IntelligencePortClient implements IntelligenceService {
     }
     if (!this.pollPending) {
       this.pollPending = true;
-      this.port.postMessage({ kind: 'intelligence-poll', maxEvents: count });
+      try {
+        this.port.postMessage({ kind: 'intelligence-poll', maxEvents: count });
+      } catch {
+        this.markClosed();
+        this.releaseTransport();
+        return [];
+      }
     }
     return events;
   }
@@ -258,16 +298,32 @@ export class IntelligencePortClient implements IntelligenceService {
         }),
       );
     }
-    this.port.postMessage({ kind: 'intelligence-cancel', activityId: id });
+    try {
+      this.port.postMessage({ kind: 'intelligence-cancel', activityId: id });
+    } catch {
+      this.markClosed();
+      this.releaseTransport();
+      return err(new IntelligenceError({ code: 'intelligence-closed', detail: {} }));
+    }
     return ok(undefined);
   }
 
   close(): Promise<void> {
     if (this.closeTask !== undefined) return this.closeTask;
-    this.closed = true;
+    if (this.closed) {
+      this.closeTask = Promise.resolve();
+      return this.closeTask;
+    }
+    this.markClosed();
     this.closeTask = new Promise((resolve) => {
       this.closeResolve = resolve;
-      this.port.postMessage({ kind: 'intelligence-close' });
+      try {
+        this.port.postMessage({ kind: 'intelligence-close' });
+      } catch {
+        this.releaseTransport();
+        this.closeResolve = undefined;
+        resolve();
+      }
     });
     return this.closeTask;
   }