@forgeax/engine-intelligence 0.1.6 → 0.1.7

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);
@@ -76,19 +78,18 @@ export function bindIntelligencePort(
       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) {
+    closeTask = (async () => {
+      await runtime.close();
       port.postMessage({ kind: 'intelligence-closed' });
       setTimeout(() => port.close(), 0);
-    } else {
-      port.close();
-    }
+    })();
+    return closeTask;
   };
   port.addEventListener('message', listener);
   port.start?.();
@@ -157,6 +158,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 +169,26 @@ export class IntelligencePortClient implements IntelligenceService {
         this.active.delete(message.activityId);
         this.rejected.set(message.activityId, message);
       } else if (message.kind === 'intelligence-closed') {
+        this.markClosed();
         this.port.removeEventListener('message', this.listener);
-        this.received.length = 0;
-        this.active.clear();
-        this.rejected.clear();
         this.port.close();
         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;
+  }
+
   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) {
@@ -264,7 +273,11 @@ export class IntelligencePortClient implements IntelligenceService {
 
   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' });