Skip Diceroll when a manual instruction steers the generation Guided Generations (and similar tools) inject their custom instruction via /inject id=instruct before triggering a swipe or response. When such an inject is active — the id list is configurable, default "instruct" — or the generation was started with its own custom prompt, Diceroll neither rolls nor injects a direction, letting the manual instruction steer alone. Plain swipes afterwards dice again as usual.

f328c40cd00cca6de77d6d3eeead02277509c900

permissionBRICK <40219477+permissionBRICK@users.noreply.github.com>

public/scripts/extensions/diceroll/index.js+48 -0 Viewed

     useStructuredOutput: true,
     notify: true,
     debugDisplay: false,
+    // Comma-separated /inject ids whose presence means another tool is already steering this
+    // generation (Guided Generations uses id "instruct" for guided response/swipe/corrections).
+    skipInjectIds: 'instruct',
     optionsPrompt: DEFAULT_OPTIONS_PROMPT,
     directionTemplate: DEFAULT_DIRECTION_TEMPLATE,
 };

 // Roll data waiting to be stamped onto the message the steered generation produces.
 let pendingStamp = null;
+// Whether the main generation being intercepted was started with its own custom prompt
+// (e.g. a swipe/regenerate triggered with an additional instruction). Tracked via
+// GENERATION_STARTED because the interceptor does not receive the generation params.
+let mainGenHasCustomPrompt = false;
 globalThis.dicerollGenerateInterceptor = (...args) => onGenerationIntercept(...args);
 function getSettings() {

     return extension_settings[MODULE];
+}
+/**
+ * True when another tool is already steering this generation with a manual instruction:
+ * either a script inject with a configured id (Guided Generations' guided swipe/response
+ * inject `id=instruct` before triggering the generation), or a custom prompt passed
+ * directly to the generation call.
+ * @param {object} s Settings
+ * @returns {boolean}
+ */
+function hasManualSteering(s) {
+    if (mainGenHasCustomPrompt) {
+        return true;
+    }
+    const injects = chat_metadata.script_injects ?? {};
+    return String(s.skipInjectIds ?? '')
+        .split(',')
+        .map(id => id.trim())
+        .filter(Boolean)
+        .some(id => String(injects[id]?.value ?? '').trim());
+}
 function getRole(name) {
     return name === 'user' ? extension_prompt_roles.USER : extension_prompt_roles.SYSTEM;
+}

         return;
+    }
+    // A guided swipe/response (or any generation carrying its own instruction) takes precedence:
+    // no roll, no direction injection — the manual instruction alone steers this generation.
+    if (hasManualSteering(s)) {
+        console.debug('[Diceroll] Manual instruction detected, skipping the roll for this generation.');
+        return;
+    }
     // The roll belongs to the current user turn; swipes/regenerates of the same turn can reuse it.
     const anchor = chat.findLastIndex(x => x.is_user);
     const stored = chat_metadata[METADATA_KEY];

     $('#diceroll_max_options').val(s.maxOptions);
     $('#diceroll_options_role').val(s.optionsRole);
     $('#diceroll_direction_role').val(s.directionRole);
+    $('#diceroll_skip_inject_ids').val(s.skipInjectIds);
     $('#diceroll_options_prompt').val(s.optionsPrompt);
     $('#diceroll_direction_template').val(s.directionTemplate);
+}

         getSettings().directionRole = String($(this).val());
         saveSettingsDebounced();
     });
+    $('#diceroll_skip_inject_ids').on('input', function () {
+        getSettings().skipInjectIds = String($(this).val());
+        saveSettingsDebounced();
+    });
     $('#diceroll_options_prompt').on('input', function () {
         getSettings().optionsPrompt = String($(this).val());
         saveSettingsDebounced();

         delete chat_metadata[METADATA_KEY];
     });
+    // Runs before the interceptor within the same Generate() call, so the flag is always fresh.
+    // The nested option request (type 'quiet') must not overwrite the outer generation's flag.
+    eventSource.on(event_types.GENERATION_STARTED, (type, params, dryRun) => {
+        if (type !== 'quiet' && !dryRun) {
+            mainGenHasCustomPrompt = !!params?.quiet_prompt;
+        }
+    });
     eventSource.on(event_types.MESSAGE_RECEIVED, (chatId) => stampMessage(chatId));
     eventSource.on(event_types.CHARACTER_MESSAGE_RENDERED, (chatId) => {
         stampMessage(chatId);

public/scripts/extensions/diceroll/settings.html+4 -0 Viewed

                 </div>
             </div>
+            <label for="diceroll_skip_inject_ids" data-i18n="ext_diceroll_skip_inject_ids">Skip when these /inject ids are active (comma-separated)</label>
+            <input id="diceroll_skip_inject_ids" class="text_pole" type="text" placeholder="instruct" />
+            <small data-i18n="ext_diceroll_skip_inject_ids_help">When another tool steers the reply with its own instruction — e.g. Guided Generations' guided response/swipe use /inject id=instruct — Diceroll stays out of the way and neither rolls nor injects a direction for that generation. Generations triggered with a custom prompt are skipped as well.</small>
             <label for="diceroll_options_prompt" data-i18n="ext_diceroll_options_prompt">Option-generation prompt (\{{min}}, \{{max}} available)</label>
             <textarea id="diceroll_options_prompt" class="text_pole textarea_compact" rows="7"></textarea>
             <div id="diceroll_options_prompt_restore" class="menu_button menu_button_icon">