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">