@kaoruisaac/pedelec 0.1.24 → 0.1.26

package/dist/index.d.ts

@@ -224,7 +224,6 @@ export declare class Pedelec {
     private readonly sessions;
     private readonly lastSeqBySession;
     private nextRequestNumber;
-    private disconnectedError;
     private port;
     constructor(options?: PedelecOptions);
     createSession(): Promise<PedelecSession<string>>;
@@ -241,12 +240,14 @@ export declare class Pedelec {
     private resolveProviderOnlyCreateSessionInput;
     private assertDefaultProviderAvailable;
     private registerSession;
+    private ensureExtensionPort;
     private connectExtension;
     private handlePortMessage;
     private handleResponse;
     private isNewEvent;
     private handleDisconnect;
     private broadcastError;
+    private invalidateSessions;
 }
 export declare class PedelecSession<TToolName extends string = string> {
     private readonly client;
@@ -262,6 +263,7 @@ export declare class PedelecSession<TToolName extends string = string> {
     private ending;
     private prepared;
     private activeTurn;
+    private transportDetached;
     private genericToolHandler;
     private inlineToolHandlers;
     private readonly namedToolHandlers;
@@ -288,6 +290,10 @@ export declare class PedelecSession<TToolName extends string = string> {
     end(): Promise<void>;
     handleEvent(event: SessionEvent, meta?: EventDispatchMeta): void;
     replaceInlineToolHandlers(handlers: Map<string, ToolSpecificHandler>): void;
+    /** @internal */
+    isTransportDetached(): boolean;
+    /** @internal */
+    handleTransportDisconnect(error: PedelecError): void;
     private handleToolCall;
     private resolvePendingSend;
     private resolvePendingPrepare;

package/dist/index.js

@@ -122,14 +122,12 @@ export class Pedelec {
     sessions = new Map();
     lastSeqBySession = new Map();
     nextRequestNumber = 1;
-    disconnectedError = null;
     port = null;
     constructor(options = {}) {
         this.pageWindow = typeof window === "undefined" ? null : window;
         this.channelId = createChannelId();
         this.bridgeTimeoutMs = Math.max(1, options.bridgeTimeoutMs ?? DEFAULT_BRIDGE_TIMEOUT_MS);
         if (!this.pageWindow) {
-            this.disconnectedError = makeError("EXTENSION_UNAVAILABLE", "Pedelec SDK must run in a browser page context.");
             return;
         }
         this.connectExtension();
@@ -157,14 +155,6 @@ export class Pedelec {
         return normalizePedelecSettings(await this.request("get_settings"));
     }
     async getApprovalStatus() {
-        if (this.disconnectedError) {
-            return {
-                installed: false,
-                approved: false,
-                origin: getCurrentOrigin(this.pageWindow),
-                appConnected: false,
-            };
-        }
         try {
             const result = await this.request("get_approval_status");
             return result;
@@ -195,11 +185,12 @@ export class Pedelec {
         return this.registerSession(result.sessionId, "", undefined);
     }
     request(type, payload = {}) {
-        if (this.disconnectedError) {
-            return Promise.reject(this.disconnectedError);
+        let port;
+        try {
+            port = this.ensureExtensionPort();
         }
-        if (!this.port) {
-            return Promise.reject(makeError("EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable."));
+        catch (err) {
+            return Promise.reject(normalizeError(err, "EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable."));
         }
         const requestId = `sdk_${Date.now()}_${this.nextRequestNumber++}`;
         const message = { channelId: this.channelId, type, requestId, ...payload };
@@ -212,17 +203,22 @@ export class Pedelec {
                 }));
             }, this.bridgeTimeoutMs);
             this.pendingRequests.set(requestId, {
+                port,
                 resolve: (value) => resolve(value),
                 reject,
                 timeoutId,
             });
             try {
-                this.port?.postMessage(message);
+                port.postMessage(message);
             }
             catch (err) {
                 this.pendingRequests.delete(requestId);
                 clearTimeout(timeoutId);
-                reject(normalizeError(err, "EXTENSION_DISCONNECTED", "Pedelec extension disconnected."));
+                const error = normalizeError(err, "EXTENSION_DISCONNECTED", "Pedelec extension disconnected.");
+                if (this.port === port) {
+                    this.handleDisconnect(port, error);
+                }
+                reject(error);
             }
         });
     }
@@ -341,7 +337,7 @@ export class Pedelec {
     }
     registerSession(sessionId, provider, model, inlineToolHandlers = new Map()) {
         const existing = this.sessions.get(sessionId);
-        if (existing) {
+        if (existing && !existing.isTransportDetached()) {
             existing.replaceInlineToolHandlers(inlineToolHandlers);
             return existing;
         }
@@ -349,23 +345,40 @@ export class Pedelec {
         this.sessions.set(sessionId, session);
         return session;
     }
-    connectExtension() {
+    ensureExtensionPort() {
+        if (this.port)
+            return this.port;
+        if (!this.pageWindow) {
+            throw makeError("EXTENSION_UNAVAILABLE", "Pedelec SDK must run in a browser page context.");
+        }
         const runtime = globalThis.chrome?.runtime;
         if (!runtime?.connect) {
-            this.disconnectedError = makeError("EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
-            return;
+            throw makeError("EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
         }
         try {
-            this.port = runtime.connect(PEDELEC_EXTENSION_ID, { name: SDK_EXTERNAL_PORT_NAME });
-            this.port.onMessage.addListener((message) => this.handlePortMessage(message));
-            this.port.onDisconnect.addListener(() => this.handleDisconnect());
+            const port = runtime.connect(PEDELEC_EXTENSION_ID, { name: SDK_EXTERNAL_PORT_NAME });
+            port.onMessage.addListener((message) => this.handlePortMessage(port, message));
+            port.onDisconnect.addListener(() => this.handleDisconnect(port));
+            this.port = port;
+            return port;
         }
         catch (err) {
-            this.disconnectedError = normalizeError(err, "EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
             this.port = null;
+            throw normalizeError(err, "EXTENSION_UNAVAILABLE", "Pedelec extension is unavailable.");
+        }
+    }
+    connectExtension() {
+        try {
+            this.ensureExtensionPort();
+        }
+        catch (_err) {
+            // The first connection is eager for normal browser startup, but a failed
+            // attempt remains retryable through the next request.
         }
     }
-    handlePortMessage(raw) {
+    handlePortMessage(port, raw) {
+        if (port !== this.port)
+            return;
         const message = raw;
         if (!message || typeof message !== "object")
             return;
@@ -411,23 +424,31 @@ export class Pedelec {
         this.lastSeqBySession.set(event.sessionId, event.seq);
         return true;
     }
-    handleDisconnect() {
+    handleDisconnect(port, disconnectError) {
+        if (port !== this.port)
+            return;
         const runtime = globalThis.chrome?.runtime;
-        const error = normalizeError(runtime?.lastError, "EXTENSION_DISCONNECTED", "Pedelec extension disconnected.");
-        this.disconnectedError = error;
+        const error = normalizeError(disconnectError ?? runtime?.lastError, "EXTENSION_DISCONNECTED", "Pedelec extension disconnected.");
         this.port = null;
-        for (const pending of this.pendingRequests.values()) {
+        this.invalidateSessions(error);
+        for (const [requestId, pending] of this.pendingRequests) {
+            if (pending.port !== port)
+                continue;
+            this.pendingRequests.delete(requestId);
             clearTimeout(pending.timeoutId);
             pending.reject(error);
         }
-        this.pendingRequests.clear();
-        this.broadcastError(error);
     }
     broadcastError(error) {
         for (const session of this.sessions.values()) {
             session.handleEvent({ type: "error", sessionId: session.sessionId, error }, { source: "sdk" });
         }
     }
+    invalidateSessions(error) {
+        for (const session of this.sessions.values()) {
+            session.handleTransportDisconnect(error);
+        }
+    }
 }
 export class PedelecSession {
     client;
@@ -443,6 +464,7 @@ export class PedelecSession {
     ending = false;
     prepared = false;
     activeTurn = null;
+    transportDetached = false;
     genericToolHandler = null;
     inlineToolHandlers = new Map();
     namedToolHandlers = new Map();
@@ -458,7 +480,7 @@ export class PedelecSession {
         this.inlineToolHandlers = new Map(inlineToolHandlers);
     }
     prepare() {
-        if (this.status === "ended") {
+        if (this.transportDetached || this.status === "ended") {
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
         }
         if (this.pendingSend) {
@@ -482,7 +504,8 @@ export class PedelecSession {
         })
             .catch((err) => {
             const error = normalizeError(err, "PREPARE_FAILED", "prepare failed");
-            this.emitError(error, { source: "sdk" });
+            if (!this.transportDetached)
+                this.emitError(error, { source: "sdk" });
             this.clearPendingPrepare();
             this.finishActiveTurn(turn);
             throw error;
@@ -505,7 +528,7 @@ export class PedelecSession {
                 // prepare is an optimization; sendText falls back to the original first-run path.
             }
         }
-        if (this.status === "ended") {
+        if (this.transportDetached || this.status === "ended") {
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
         }
         if (this.pendingSend || this.pendingPrepare) {
@@ -524,7 +547,8 @@ export class PedelecSession {
         })
             .catch((err) => {
             const error = normalizeError(err, "SEND_TEXT_FAILED", "sendText failed");
-            this.emitError(error, { source: "sdk" });
+            if (!this.transportDetached)
+                this.emitError(error, { source: "sdk" });
             this.clearPendingSend();
             this.finishActiveTurn(turn);
             throw error;
@@ -560,7 +584,7 @@ export class PedelecSession {
         };
     }
     uploadAsset(file, targetPath) {
-        if (this.ending || this.status === "ended")
+        if (this.transportDetached || this.ending || this.status === "ended")
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
         if (this.uploadPromise) {
             return Promise.reject(makeError("SESSION_BUSY", "session is busy", { sessionId: this.sessionId }));
@@ -601,13 +625,13 @@ export class PedelecSession {
         return this.uploadPromise;
     }
     listAssets() {
-        if (this.ending || this.status === "ended") {
+        if (this.transportDetached || this.ending || this.status === "ended") {
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
         }
         return this.client.request("list_assets", { sessionId: this.sessionId }).then(normalizeListAssetsResponse);
     }
     readAsset(path, type) {
-        if (this.ending || this.status === "ended")
+        if (this.transportDetached || this.ending || this.status === "ended")
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
         if (!isValidAssetPath(path) || !["text", "json", "file"].includes(type)) {
             return Promise.reject(makeError("ASSET_PATH_INVALID", "asset path or read type is invalid"));
@@ -671,8 +695,12 @@ export class PedelecSession {
         return this.status;
     }
     async end() {
-        if (this.status === "ended" || this.ending)
+        if (this.transportDetached || this.status === "ended" || this.ending) {
+            if (this.transportDetached) {
+                throw makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId });
+            }
             return;
+        }
         this.ending = true;
         try {
             await this.client.request("end_session", {
@@ -742,6 +770,19 @@ export class PedelecSession {
     replaceInlineToolHandlers(handlers) {
         this.inlineToolHandlers = new Map(handlers);
     }
+    /** @internal */
+    isTransportDetached() {
+        return this.transportDetached;
+    }
+    /** @internal */
+    handleTransportDisconnect(error) {
+        if (this.transportDetached)
+            return;
+        this.transportDetached = true;
+        this.setStatus("error", { source: "sdk" });
+        this.emitError(error, { source: "sdk" });
+        this.rejectActivePending(error);
+    }
     async handleToolCall(event, meta, turn) {
         let result;
         const namedHandler = this.namedToolHandlers.get(event.tool);
@@ -783,6 +824,8 @@ export class PedelecSession {
                 }),
             };
         }
+        if (this.transportDetached)
+            return;
         try {
             await this.client.request("submit_tool_result", {
                 sessionId: this.sessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaoruisaac/pedelec",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",