dsh-plugin-subscription-oauth 0.17.2 → 0.17.4

package/lib/client/FastModeButton.js

@@ -94,7 +94,11 @@ export function FastModeButton({ call, isOwnProvider, modelDirectory, useProject
     }, [provider, model, isOwnProvider, call]);
     // A switch that landed clears the reason, so the marker follows the truth on screen.
     useEffect(() => { setFailure(undefined); }, [model]);
-    if (pair === undefined || provider === undefined || model === undefined || modelDirectory?.select === undefined)
+    // The button renders on the fast pair alone. The host's model directory can be a moment
+    // late (its `remote.session` dependency starts after the composer mounts), so gating
+    // rendering on the directory being ready here hid the button for the whole session.
+    // `modelDirectory.select` resolves the directory lazily on click instead.
+    if (pair === undefined || provider === undefined || model === undefined)
         return null;
     // Fast mode is the row's fast reasoning rung, so the model id never changes and the
     // picker always shows the row the user can switch back to.
@@ -113,7 +117,12 @@ export function FastModeButton({ call, isOwnProvider, modelDirectory, useProject
                     // Turning it off drops the rung, which the host then reads as the model's own
                     // default. The model id is never swapped, so this cannot strand the selection.
                     const next = active ? { provider, model: target } : { provider, model: target, reasoningEffort: pair.rung };
-                    void Promise.resolve(modelDirectory.select?.(next))
+                    if (modelDirectory?.select === undefined) {
+                        setFailure({ message: 'the model directory is unavailable on this host' });
+                        setPending(false);
+                        return;
+                    }
+                    void Promise.resolve(modelDirectory.select(next))
                         .then((result) => {
                         // The directory reports its own outcome: a refused selection carries why.
                         const outcome = result;

package/lib/client/index.js

@@ -103,29 +103,41 @@ export function apply(ctx) {
 /**
  * The session's model directory, in the shape the quick-mode button writes through.
  *
- * Absent when the host exposes no directory for the session, or exposes one that cannot
- * select — in which case the button renders nothing rather than a dead control.
+ * The lookup is lazy: the returned `select` resolves the host's directory on first use,
+ * not at inject time. The host's `directoryFor` throws while its own `remote.session`
+ * dependency is still starting (observed on desktop), so resolving eagerly at mount hid
+ * the button for the whole session even though the directory became ready a moment later.
  *
  * @param modelDirectories - the host's directory resolver, when it has one.
  * @param sessionId - the session whose directory is wanted.
- * @returns the reader/writer pair, or undefined.
+ * @returns the writer, or undefined when there is no resolver or session at all.
  */
 function modelDirectoryFor(modelDirectories, sessionId) {
     if (sessionId === undefined || modelDirectories?.directoryFor === undefined)
         return undefined;
-    // The host throws when the session has no directory yet (a fresh session, say); that is
-    // a missing control, not a fault, so the button renders nothing instead of breaking the
-    // whole composer.
-    let directory;
-    try {
-        directory = modelDirectories.directoryFor(sessionId);
-    }
-    catch {
-        return undefined;
-    }
-    if (directory?.select === undefined)
-        return undefined;
+    // A lazily-resolved select: the first call walks the host's directory; a throw there is
+    // a transient startup miss, so it is retried once after a short beat before failing.
     return {
-        select: (selection) => directory.select?.(selection) ?? Promise.resolve(),
+        select: async (selection) => {
+            const resolve = () => modelDirectories.directoryFor?.(sessionId);
+            let directory = (() => { try {
+                return resolve();
+            }
+            catch {
+                return undefined;
+            } })();
+            if (directory?.select === undefined) {
+                await new Promise((resolveWait) => setTimeout(resolveWait, 500));
+                try {
+                    directory = resolve();
+                }
+                catch {
+                    directory = undefined;
+                }
+            }
+            if (directory?.select === undefined)
+                throw new Error('the model directory is not available yet; try again');
+            return directory.select(selection);
+        },
     };
 }

package/lib/client.js

@@ -3123,7 +3123,7 @@ function FastModeButton({ call, isOwnProvider, modelDirectory, useProjection })
 	(0, react.useEffect)(() => {
 		setFailure(void 0);
 	}, [model]);
-	if (pair === void 0 || provider === void 0 || model === void 0 || modelDirectory?.select === void 0) return null;
+	if (pair === void 0 || provider === void 0 || model === void 0) return null;
 	const active = (selection?.next ?? selection?.lastUsed)?.reasoningEffort === pair.rung;
 	const target = model;
 	const base = active ? "Fast mode is on; press to go back to the standard model" : "Fast mode: switch to this model’s fast variant";
@@ -3150,7 +3150,12 @@ function FastModeButton({ call, isOwnProvider, modelDirectory, useProjection })
 				model: target,
 				reasoningEffort: pair.rung
 			};
-			Promise.resolve(modelDirectory.select?.(next)).then((result) => {
+			if (modelDirectory?.select === void 0) {
+				setFailure({ message: "the model directory is unavailable on this host" });
+				setPending(false);
+				return;
+			}
+			Promise.resolve(modelDirectory.select(next)).then((result) => {
 				const outcome = result;
 				if (outcome?.ok !== false) return;
 				const code = outcome.error?.code;
@@ -3286,23 +3291,37 @@ function apply(ctx) {
 /**
 * The session's model directory, in the shape the quick-mode button writes through.
 *
-* Absent when the host exposes no directory for the session, or exposes one that cannot
-* select — in which case the button renders nothing rather than a dead control.
+* The lookup is lazy: the returned `select` resolves the host's directory on first use,
+* not at inject time. The host's `directoryFor` throws while its own `remote.session`
+* dependency is still starting (observed on desktop), so resolving eagerly at mount hid
+* the button for the whole session even though the directory became ready a moment later.
 *
 * @param modelDirectories - the host's directory resolver, when it has one.
 * @param sessionId - the session whose directory is wanted.
-* @returns the reader/writer pair, or undefined.
+* @returns the writer, or undefined when there is no resolver or session at all.
 */
 function modelDirectoryFor(modelDirectories, sessionId) {
 	if (sessionId === void 0 || modelDirectories?.directoryFor === void 0) return void 0;
-	let directory;
-	try {
-		directory = modelDirectories.directoryFor(sessionId);
-	} catch {
-		return;
-	}
-	if (directory?.select === void 0) return void 0;
-	return { select: (selection) => directory.select?.(selection) ?? Promise.resolve() };
+	return { select: async (selection) => {
+		const resolve = () => modelDirectories.directoryFor?.(sessionId);
+		let directory = (() => {
+			try {
+				return resolve();
+			} catch {
+				return;
+			}
+		})();
+		if (directory?.select === void 0) {
+			await new Promise((resolveWait) => setTimeout(resolveWait, 500));
+			try {
+				directory = resolve();
+			} catch {
+				directory = void 0;
+			}
+		}
+		if (directory?.select === void 0) throw new Error("the model directory is not available yet; try again");
+		return directory.select(selection);
+	} };
 }
 
 //#endregion