# Github

GitHub automations automatically create issues in your repositories when recordings or captures are added to a folder. Convert customer bug reports, feature requests, and support tickets into actionable GitHub issues with video evidence and console logs.

<figure><img src="/files/TyJASEm0d1j0UrskOVG9" alt=""><figcaption></figcaption></figure>

***

### When to Use GitHub Automations

GitHub automations are ideal for:

* **Bug Report Tracking** — Convert customer-reported bugs into GitHub issues with video evidence
* **Feature Request Management** — Automatically create enhancement issues from customer feedback
* **Support Escalations** — Create high-priority issues when critical problems are reported
* **Cross-Team Collaboration** — Link customer recordings directly to development work
* **Engineering Visibility** — Ensure engineers see customer context immediately
* **Issue Triage Workflow** — Route issues to specific repositories and projects automatically

{% hint style="info" %}
**GitHub vs. Email/Webhook**

Use GitHub when:

* Your engineering team uses GitHub for issue tracking
* You want automatic issue creation with full context
* You need to organize issues by repository
* You want to assign issues to team members
* You need bi-directional sync with status updates

Use Email when:

* Recipients don't use GitHub
* You just need notifications
* You want simpler setup without OAuth

Use Webhooks when:

* You need integration with a different tool
* You want custom payload formatting
* You're building custom automation
  {% endhint %}

***

### Prerequisites

Before setting up GitHub automations:

1. **GitHub Account** — With repository write access
2. **Repository Access** — Admin or write access to target repositories
3. **Screendesk Plan** — Pro or Enterprise plan to enable automations
4. **Folder** — Created in Screendesk to trigger the automation

***

### Setup

#### Connect GitHub to Screendesk (First-time only)

Navigate to your integrations:

1. Click your avatar in the top right corner
2. Select **Account Settings**
3. Go to **Integrations & Automations → Integrations**
4. Find **GitHub** in the list
5. Click **Connect GitHub**

You'll be redirected to GitHub to authorize access. You'll see a dialog showing the permissions Screendesk requires:

* Create and read issues
* Read repository metadata
* Read organization members (for assignees)

Click **Install & Authorize** to proceed.

{% hint style="warning" %}
**GitHub App Installation**

You'll need to select installation scope:

* **All repositories** — Screendesk can access all current and future repos
* **Select repositories** — Choose specific repos you want to allow

You can change this anytime in GitHub settings.
{% endhint %}

#### Review GitHub connection status

After authorization completes, you'll return to **Account Settings → Integrations**.

You should see:

* ✅ **GitHub Connected** with your account name
* List of accessible repositories
* **Disconnect** button (if you need to remove the integration)

{% hint style="success" %}
**Connection Verified**

If you see your username and repositories list, GitHub is successfully connected. You can now create automations in any folder.
{% endhint %}

#### Open folder automations

Create an automation in any folder:

1. Navigate to the folder you want to automate
2. Click **Settings** (gear icon) in the top right
3. Select the **Automations** tab
4. Click **+ Add Automation**
5. Select **GitHub** from the integration list

#### Select target repository

Configure where issues will be created:

**Repository (required):**

* Select the GitHub repository where issues will be created
* Only repositories with write access appear in the dropdown
* Can't find your repo? Verify GitHub App installation includes it
* Click **Refresh** to reload the repository list

**Note:** Each automation targets one repository. Create multiple automations for multiple repositories.

{% hint style="info" %}
**Repository Selection**

If you don't see expected repositories:

1. Ensure GitHub App installation includes them
2. Verify you have write access to the repo
3. Click **Refresh** in the GitHub integration settings
4. Re-save your automation
   {% endhint %}

#### Configure issue title

Customize how issue titles appear in GitHub:

**Default title template:**

```
{{item.title}}
```

**Example outputs:**

```
Checkout page crashes on iOS
User can't reset password
Feature request: Dark mode toggle
```

**Other title examples:**

For bug reports:

```
🐛 {{item.title}}
```

For feature requests:

```
💡 Feature: {{item.title}}
```

Including customer context:

```
[{{creator.email}}] {{item.title}}
```

For folder-specific routing:

```
[{{folder.name}}] {{item.title}}
```

{% hint style="warning" %}
**Title Length**

Keep titles under 100 characters for clarity. GitHub will display full titles but very long titles may be truncated in lists.
{% endhint %}

View all available template variables →

#### Configure issue description

Create a rich issue description with recording context:

**Default description template:**

```markdown
## Recording from Screendesk

**Title:** {{item.title}}
**From:** {{creator.name}} ({{creator.email}})
**Folder:** {{folder.name}}

**View recording:** {{item.url}}

---

This issue was automatically created from a recording uploaded to Screendesk.
```

**Example: Detailed bug report description**

```markdown
## Bug Report

A customer submitted a recording that describes this issue.

**Reported by:** {{creator.email}} ({{creator.name}})
**Folder:** {{folder.name}}

### Description
{{item.title}}

### Watch Recording
[View on Screendesk]({{item.url}})

---

### Recording Details
| Property | Value |
|----------|-------|
| Duration | {{item.duration}} seconds |
| Browser | {{item.browser}} |
| OS | {{item.os}} |
| Resolution | {{item.resolution}} |
| Location | {{item.country}} |
| Recorded | {{item.created_at}} |

### Technical Information

**Console Errors:**
\`\`\`
{{item.console_errors}}
\`\`\`

**Network Errors:**
\`\`\`
{{item.network_errors}}
\`\`\`

---

This issue was automatically created from a customer recording on Screendesk.
```

**Example: Feature request description**

```markdown
## Feature Request

A customer requested the following feature.

**Suggested by:** {{creator.email}} ({{creator.name}})

### Feature Description
{{item.title}}

### Customer Recording
[View request on Screendesk]({{item.url}})

**Recording Duration:** {{item.duration}} seconds

---

This feature request was automatically created from a customer recording.
```

**GitHub Markdown Support**

GitHub descriptions support GitHub-Flavored Markdown:

* **Bold** — `**text**`
* *Italic* — `*text*`
* Code blocks — ` ``` `
* Links — `[text](url)`
* Headers — `## Heading`
* Lists — `* item`
* Task lists — `- [ ] item`
* Collapsible sections — `<details>`

Use markdown to format important information effectively. {% endhint %}

View all available variables → {% endstep %}

{% step %}

#### Apply labels automatically

Organize issues with GitHub labels:

**To add labels:**

1. Click **+ Add Label**
2. Select from your repository's available labels
3. Add multiple labels as needed

**Suggested labels:**

* `from-screendesk` — Track all automated issues
* `customer-reported` — Mark customer submissions
* `needs-triage` — Flag for manual review
* `bug` or `enhancement` — Categorize issue type
* `critical` — For urgent folders
* `customer-feedback` — Specific to feature requests

**Example configurations:**

For bug reports folder:

```

from-screendesk, customer-reported, bug, needs-triage
```

For feature requests folder:

```
from-screendesk, enhancement, customer-feedback
```

For critical issues folder:

```
from-screendesk, critical, urgent
```

{% hint style="warning" %} **Label Availability**

Only labels that exist in your repository appear in the dropdown. If you don't see a label you want:

1. Create it in GitHub first
2. Return to Screendesk
3. Click **Refresh** in the GitHub integration settings
4. The new label will appear in the dropdown {% endhint %} {% endstep %}

{% step %}

#### Assign team members (optional)

Auto-assign issues to team members:

**Assignee dropdown:**

* Select specific team members
* Multiple assignees supported
* Or leave unassigned for manual assignment
* Only active repository members appear in the list

**Recommended approach:**

* Leave unassigned for most automations
* Use assignee for on-call or urgent issues
* Let team leads manually assign based on expertise

**Example uses:**

* Assign critical bugs to on-call engineer
* Assign feature requests to product manager
* Leave general issues unassigned for triage

{% hint style="info" %} **Multiple Assignees**

GitHub supports multiple assignees per issue. Add team members to distribute work:

* Bug triage: Add QA and backend leads
* Feature requests: Add product and design
* Critical issues: Add on-call engineer and team lead {% endhint %} {% endstep %}

{% step %}

#### Test the automation

Before activating, create a test issue:

1. Click **Create Test Issue** button
2. Check your GitHub repository for the new issue
3. Verify all fields populated correctly:
   * [ ] Title matches template
   * [ ] Description includes all variables
   * [ ] Repository is correct
   * [ ] Labels are applied
   * [ ] Assignees are set (if configured)
   * [ ] Recording link works
   * [ ] Markdown renders properly

**If something looks wrong:**

1. Click **Back**
2. Update the settings
3. Click **Create Test Issue** again

**Delete test issues in GitHub:** After verifying, you can delete test issues directly in GitHub (they won't affect the automation).

{% hint style="success" %} **Ready to Activate**

Once testing passes, proceed to save. {% endhint %} {% endstep %}

{% step %}

#### Save and activate

Finalize the automation:

1. Click **Save Automation**
2. The automation is **enabled by default**
3. You'll see it listed in the folder's **Automations** tab

**Status indicators:**

* ✅ Green toggle — Automation is active
* ⚫ Gray toggle — Automation is disabled

You can disable/enable the automation anytime without deleting it.

From now on, every recording or capture added to this folder will automatically create an issue in GitHub.

{% hint style="info" %} **Automation Activity**

View execution history:

1. Go to **Account Settings → Automations → Execution Log**
2. Filter by folder or automation type
3. See success/failure details for each execution {% endhint %} {% endstep %} {% endstepper %}

***

### Template Variables

Use these variables in title and description templates:

#### Item Information

| Variable              | Description                | Example                  |
| --------------------- | -------------------------- | ------------------------ |
| `{{item.title}}`      | Recording or capture title | "Checkout crashes"       |
| `{{item.url}}`        | Link to recording/capture  | Full HTTPS URL           |
| `{{item.type}}`       | Item type                  | "recording" or "capture" |
| `{{item.duration}}`   | Length in seconds          | "45"                     |
| `{{item.created_at}}` | Submission timestamp       | "Feb 6, 2026 at 2:30 PM" |

#### Creator Information

| Variable            | Description          | Example                |
| ------------------- | -------------------- | ---------------------- |
| `{{creator.name}}`  | Person who submitted | "Alice Johnson"        |
| `{{creator.email}}` | Creator's email      | "<alice@customer.com>" |

#### Recording-Specific (if applicable)

| Variable                       | Description          | Example               |
| ------------------------------ | -------------------- | --------------------- |
| `{{recording.title}}`          | Recording title      | "Checkout page error" |
| `{{recording.url}}`            | Recording link       | Full HTTPS URL        |
| `{{recording.browser}}`        | Browser info         | "Chrome 121.0.6167"   |
| `{{recording.os}}`             | Operating system     | "macOS 14.3"          |
| `{{recording.resolution}}`     | Screen resolution    | "2560x1440"           |
| `{{recording.country}}`        | Geographic location  | "United States"       |
| `{{recording.console_errors}}` | JavaScript errors    | Formatted list        |
| `{{recording.network_errors}}` | Failed HTTP requests | Formatted list        |

#### Capture-Specific (if applicable)

| Variable            | Description   | Example                     |
| ------------------- | ------------- | --------------------------- |
| `{{capture.title}}` | Capture title | "Bug description"           |
| `{{capture.url}}`   | Capture link  | Full HTTPS URL              |
| `{{capture.type}}`  | Capture type  | Screenshot or document type |

#### Folder & Account

| Variable           | Description    | Example       |
| ------------------ | -------------- | ------------- |
| `{{folder.name}}`  | Folder name    | "Bug Reports" |
| `{{account.name}}` | Workspace name | "Acme Corp"   |

View complete variable reference →

***

### Example Configurations

#### Example 1: Bug Report Automation

**Folder:** Bug Reports **Target:** Report customer bugs to engineering team

**Configuration:**

| Setting    | Value                                         |
| ---------- | --------------------------------------------- |
| Repository | `acme/frontend`                               |
| Labels     | `from-screendesk`, `bug`, `customer-reported` |
| Assignees  | Unassigned (for triage)                       |

**Title Template:**

```

🐛 {{item.title}}
```

**Description Template:**

```markdown
## Customer Bug Report

A customer submitted a recording describing this issue.

**Reported by:** {{creator.email}} ({{creator.name}})
**Folder:** {{folder.name}}

### Description
{{item.title}}

### Watch Recording
[View on Screendesk]({{item.url}})

---

### System Information
| Property | Value |
|----------|-------|
| Browser | {{recording.browser}} |
| Operating System | {{recording.os}} |
| Resolution | {{recording.resolution}} |
| Location | {{recording.country}} |
| Duration | {{recording.duration}} seconds |
| Submitted | {{recording.created_at}} |

### Technical Details

**Console Errors:**
\`\`\`
{{recording.console_errors}}
\`\`\`

**Network Errors:**
\`\`\`
{{recording.network_errors}}
\`\`\`

---

This issue was automatically created from a customer recording on Screendesk.
```

**Result:** Issues created with full bug context, ready for engineer triage and investigation.

***

#### Example 2: Feature Request Automation

**Folder:** Feature Requests **Target:** Track customer feature suggestions for product team

**Configuration:**

| Setting    | Value                                                 |
| ---------- | ----------------------------------------------------- |
| Repository | `acme/product-feedback`                               |
| Labels     | `from-screendesk`, `enhancement`, `customer-feedback` |
| Assignees  | (Unassigned)                                          |

**Title Template:**

```
💡 Feature Request: {{item.title}}
```

**Description Template:**

```markdown
## Customer Feature Request

A customer has requested the following feature.

**Suggested by:** {{creator.name}} ({{creator.email}})
**Folder:** {{folder.name}}

### Feature Description
{{item.title}}

### Customer Recording
[View feature request on Screendesk]({{item.url}})

**Recording Duration:** {{recording.duration}} seconds

---

This feature request was automatically created from a customer recording.
```

**Result:** Feature requests flow directly to product team for evaluation and roadmap planning.

***

#### Example 3: Critical Issue Automation (High Priority)

**Folder:** Critical Issues **Target:** Escalate urgent problems to on-call engineer immediately

**Configuration:**

| Setting    | Value                                                         |
| ---------- | ------------------------------------------------------------- |
| Repository | `acme/frontend`                                               |
| Labels     | `from-screendesk`, `critical`, `urgent`, `customer-impacting` |
| Assignees  | On-Call Engineer                                              |

**Title Template:**

```
🚨 CRITICAL: {{item.title}}
```

**Description Template:**

```markdown
## CRITICAL ISSUE ALERT

A critical production issue has been reported.

**Reported by:** {{creator.email}} ({{creator.name}})

### Issue Details
{{item.title}}

### Watch Recording
[View Screendesk Recording]({{item.url}})

---

**IMMEDIATE ACTION REQUIRED**

This issue requires investigation as soon as possible.

**Timeline:**
* Submitted: {{recording.created_at}}
* Severity: CRITICAL

**Environment:**
* Browser: {{recording.browser}}
* OS: {{recording.os}}
* Location: {{recording.country}}

---

[Assigned to: On-Call Engineer]
```

**Result:** Critical issues immediately become high-visibility tickets assigned to on-call engineers.

***

#### Example 4: Support Escalation Automation

**Folder:** Escalations **Target:** Create tickets when support team escalates customer issues

**Configuration:**

| Setting    | Value                                                   |
| ---------- | ------------------------------------------------------- |
| Repository | `acme/support-issues`                                   |
| Labels     | `from-screendesk`, `support-escalation`, `needs-triage` |
| Assignees  | Support Lead                                            |

**Title Template:**

```
[ESCALATED] {{item.title}} - {{creator.email}}
```

**Description Template:**

```markdown
## Support Escalation

The support team has escalated this issue from a customer.

**Customer:** {{creator.name}} ({{creator.email}})
**Escalated at:** {{item.created_at}}

### Customer Issue
{{item.title}}

### Supporting Evidence
[View Recording]({{item.url}})

**Duration:** {{recording.duration}} seconds
**Browser:** {{recording.browser}}
**OS:** {{recording.os}}

---

This customer has been waiting for resolution. Please prioritize.
```

**Result:** Support escalations create visible tickets that go directly to support leads.

***

### Managing the Integration

#### View Integration Status

Check GitHub connection status:

1. Go to **Account Settings**
2. Select **Integrations & Automations**
3. Find **GitHub** in the integrations list
4. See connection status and account information

**Displayed information:**

* Connection status (Connected/Disconnected)
* Account name
* Number of accessible repositories
* Last sync status

#### Configure Repository Access

Modify which repositories Screendesk can access:

1. Go to **Account Settings → Integrations & Automations**
2. Find **GitHub**
3. Click **Configure GitHub App**
4. Add or remove repositories from installation
5. Return to Screendesk

#### Disconnect GitHub

Remove the GitHub integration:

1. Go to **Account Settings → Integrations & Automations**
2. Find **GitHub**
3. Click **Disconnect**
4. Confirm disconnection

**What happens:**

* All GitHub automations are **disabled** (not deleted)
* Existing issues in GitHub **remain unchanged**
* Sync stops immediately
* Automations can be re-enabled by reconnecting

#### Refresh Repositories

If GitHub resources aren't loading:

1. Go to **Account Settings → Integrations & Automations**
2. Find **GitHub**
3. Click **Refresh**
4. Repositories update immediately

**When to refresh:**

* New repositories created in GitHub
* Repository access changed
* Permissions modified

***

### Troubleshooting

#### Issues Not Creating

**Symptom:** Automations enabled but no issues appear in GitHub

**Solutions:**

{% stepper %} {% step %}

#### Verify GitHub is connected

1. Go to **Account Settings → Integrations & Automations**
2. Check GitHub status shows "Connected"
3. If disconnected, click **Connect GitHub** to re-authorize {% endstep %}

{% step %}

#### Check repository permissions

1. Verify you have write access to the selected repository
2. Check that the GitHub App installation includes the repository
3. Try selecting a different repository to test {% endstep %}

{% step %}

#### Verify automation is enabled

1. Open folder **Settings → Automations**
2. Find the GitHub automation
3. Toggle should be **green** (on)
4. If disabled, click to enable {% endstep %}

{% step %}

#### Check execution logs

1. Go to **Account Settings → Automations → Execution Log**
2. Filter by the folder or automation
3. Look for error messages explaining why issue creation failed
4. Recent failures show detailed error information {% endstep %}

{% step %}

#### Test with a test issue

1. Open the automation
2. Click **Create Test Issue**
3. If test fails, error message explains why
4. Fix the issue and test again

{% hint style="info" %} Test issues show specific error messages that help diagnose problems. {% endhint %} {% endstep %} {% endstepper %}

#### Missing or Incorrect Fields

**Symptom:** GitHub issue created but fields are empty or wrong

**Solutions:**

{% stepper %} {% step %}

#### Verify template syntax

Check title and description templates:

* Variables must be enclosed in double braces: `{{variable}}`
* Variable names must be spelled exactly
* No extra spaces or special characters

**Correct:** `{{item.title}}` **Incorrect:** `{{ item.title }}` or `{{item.Title}}` {% endstep %}

{% step %}

#### Check data availability

Some variables only exist for certain item types:

* `{{recording.*}}` — Only for recordings
* `{{capture.*}}` — Only for captures
* `{{creator.*}}` — Available for all items

If a recording doesn't have console errors, `{{recording.console_errors}}` will be empty. {% endstep %}

{% step %}

#### Test with sample data

Create a test recording/capture with the data you're referencing:

1. Add test item to folder
2. Create test issue
3. View the result
4. Adjust templates based on what's missing {% endstep %} {% endstepper %}

#### Wrong Repository

**Symptom:** Issue created in wrong repository

**Solutions:**

1. Open the automation settings
2. Verify **Repository** dropdown shows correct repo
3. Click **Save** to update
4. Create a test issue to verify

**Note:** Changes only affect new issues, not previously created ones.

#### Labels Not Applied

**Symptom:** Issue created but labels are missing

**Solutions:**

{% stepper %} {% step %}

#### Verify labels exist in GitHub

1. Open GitHub repository
2. Go to **Issues → Labels**
3. Check that your configured labels exist
4. Labels must be created in GitHub before using in Screendesk {% endstep %}

{% step %}

#### Refresh label list in Screendesk

1. Go to **Account Settings → Integrations & Automations**
2. Find GitHub
3. Click **Refresh**
4. Wait for labels to update
5. Edit automation and verify labels appear {% endstep %}

{% step %}

#### Re-add labels to automation

1. Open the automation settings
2. Remove old labels
3. Click **+ Add Label** to re-select
4. Choose labels from the refreshed list
5. Save and test {% endstep %} {% endstepper %}

#### Assignee Not Applied

**Symptom:** Issue not assigned to selected team member

**Solutions:**

1. Verify the selected person has **write access** to the repository
2. Person must be a collaborator on the repo
3. Go to GitHub repository settings → Manage access
4. Check if the person is listed
5. If not, add them as a collaborator
6. Select a different assignee in automation and test again

#### Rate Limiting

**Symptom:** "API rate limit exceeded" error

**Solutions:**

1. **Wait before retrying** — GitHub enforces rate limits; wait a few minutes
2. **Space out automations** — Don't trigger many automations simultaneously
3. **Check rate limit status** — View your GitHub API rate limit at github.com/settings/tokens
4. **Contact GitHub support** — If limits are too restrictive for your use case

#### Markdown Rendering Issues

**Symptom:** Description formatting looks wrong in GitHub

**Solutions:**

1. Test your Markdown template in a GitHub issue directly
2. Verify GitHub-Flavored Markdown syntax is correct
3. Common issues:
   * Missing line breaks between sections
   * Incorrect code block syntax (use triple backticks)
   * Unescaped special characters
4. Test with a test issue to verify before activating

#### OAuth Authorization Failed

**Symptom:** "GitHub authorization failed" error during connection

**Solutions:**

1. **Verify GitHub account** — Ensure you're logged into the correct account
2. **Check OAuth permissions** — Screendesk requires write access to issues
3. **Try again** — Click **Connect GitHub** to retry
4. **Clear browser cache** — OAuth may fail due to cached credentials

If issues persist, contact Screendesk support.

***

### Best Practices

#### Use Consistent Naming

Keep naming conventions consistent:

{% columns %} {% column %} **❌ Inconsistent:**

```

bug: checkout error
BUG - login failing
Customer says: password reset broken
[SEV-1] database timeout
```

{% endcolumn %}

{% column %} **✅ Consistent:**

```

🐛 Checkout page error
🐛 Login failing
🐛 Password reset broken
🐛 Database timeout
```

{% endcolumn %} {% endcolumns %}

Consistent naming makes issues easier to scan and search in GitHub.

***

#### Use Meaningful Labels

Create labels for quick filtering:

**Organizational labels:**

* `from-screendesk` — Track all automated issues
* `customer-reported` — Issues from customers
* `internal-report` — Issues from your team

**Type labels:**

* `bug`, `enhancement`, `documentation`
* `performance`, `security`, `ui`, `backend`

**Status labels:**

* `needs-triage`, `blocked`, `duplicate`
* `critical`, `high-priority`, `low-priority`

Apply 2-4 labels per issue for effective organization.

***

#### Include Recording Links Prominently

Make accessing customer evidence easy:

{% columns %} {% column %} **❌ Buried:**

```

This is a bug report.
See details below.
...lots of text...
Link: {{item.url}}
```

{% endcolumn %}

{% column %} **✅ Prominent:**

```

[View Recording]({{item.url}})

**Description:**
{{item.title}}
```

{% endcolumn %} {% endcolumns %}

Put the recording link near the top where developers will see it first.

***

#### Add Environment Context

Include technical details for debugging:

```markdown
**System Information**
| Property | Value |
|----------|-------|
| Browser | {{recording.browser}} |
| OS | {{recording.os}} |
| Resolution | {{recording.resolution}} |
| Location | {{recording.country}} |
```

This helps developers reproduce issues and understand scope.

***

#### Test Before Large Deployment

Before creating many automations:

1. Create one automation
2. Add a test recording
3. Verify in GitHub
4. Check title, description, labels, assignees
5. Adjust templates as needed
6. Then create additional automations

Testing first saves time fixing issues later.

***

#### Create Repository-Specific Automations

Organize automations by repository:

For bug reports:

* Create separate automations for `frontend`, `backend`, `mobile`
* Target appropriate teams automatically
* Makes triage more efficient

For feature requests:

* Route to `product-feedback` repository
* Assign to product manager

For support:

* Route to `support-issues` repository
* Assign to support team lead

***

#### Monitor Automation Success Rate

Regularly check execution logs:

1. Go to **Account Settings → Automations → Execution Log**
2. Filter by GitHub automations
3. Look for patterns in failures
4. Address common issues

**Target success rate:** 99%+

***

#### Document Your Setup

Keep notes on your automations:

* Why each automation exists
* What folder triggers it
* What repository it targets
* Who manages it
* When to update templates

This helps new team members understand the system.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.screendesk.io/organization-and-workflows/automations/github.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.