### Quick Setup: Create Foundry Resource

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/resource/create/references/patterns.md

Use this pattern for a straightforward setup of a single Foundry resource. It guides through resource group selection or creation and then deploys the resource. Ensure you have the Azure CLI installed and are logged in.

```bash
# Ask user: "Use existing resource group or create new?"

# ==== If user chooses "Use existing" ====
# Count and list existing resource groups
TOTAL_RG_COUNT=$(az group list --query "length([])" -o tsv)
az group list --query "[-5:].{Name:name, Location:location}" --out table

# Based on count: show appropriate list and options
# User selects resource group
RG="<selected-rg-name>"

# Fetch details to verify
az group show --name $RG --query "{Name:name, Location:location, State:properties.provisioningState}"
# Then skip to creating Foundry resource below

# ==== If user chooses "Create new" ====
# List regions and ask user to choose
az account list-locations --query "[].{Region:name}" --out table

# Variables
RG="rg-ai-services"  # New resource group name
LOCATION="westus2"  # User's chosen location
RESOURCE_NAME="my-foundry-resource"

# Create new resource group
az group create --name $RG --location $LOCATION

# Verify creation
az group show --name $RG --query "{Name:name, Location:location, State:properties.provisioningState}"

# Create Foundry resource in user's chosen location
az cognitiveservices account create \
  --name $RESOURCE_NAME \
  --resource-group $RG \
  --kind AIServices \
  --sku S0 \
  --location $LOCATION \
  --yes

# Get endpoint and keys
echo "Resource created successfully!"
az cognitiveservices account show \
  --name $RESOURCE_NAME \
  --resource-group $RG \
  --query "{Endpoint:properties.endpoint, Location:location}"

az cognitiveservices account keys list \
  --name $RESOURCE_NAME \
  --resource-group $RG
```

--------------------------------

### Azure Developer CLI Quick Start Commands

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-deploy/references/sdk/azd-deployment.md

Essential commands to get started with Azure Developer CLI: log in, initialize a project, and provision/build/deploy resources.

```bash
azd auth login
azd init
azd up    # provision + build + deploy
```

--------------------------------

### Install Frontend Dependencies and Run Locally

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/dashboard/Readme.md

Installs Node.js dependencies for the frontend and starts the development server. Run these commands from the `dashboard/` directory. The frontend will then be accessible via the URL printed in the terminal.

```bash
npm install
npm run build
npm run dev
```

--------------------------------

### Local Test Setup

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/tests/README.md

Install project dependencies, build the plugin output, and then install test-specific dependencies. Ensure you run 'npm run build' from the repo root before running tests.

```bash
# From the repo root: install dependencies and build the plugin output
npm install
npm run build

# Then install test dependencies
cd tests
npm install
```

--------------------------------

### Install Backend Dependencies and Run Locally

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/dashboard/Readme.md

Installs Node.js dependencies for the backend API and starts the development server. Ensure you are in the `dashboard/api/` directory. The default API port is 7071.

```bash
npm install
npm run dev
```

--------------------------------

### Quick Start

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-ai/references/sdk/azure-ai-vision-imageanalysis-java.md

Initialize the ImageAnalysisClient to start analyzing images.

```APIDOC
## Quick Start
```java
import com.azure.ai.vision.imageanalysis.ImageAnalysisClient;
import com.azure.ai.vision.imageanalysis.ImageAnalysisClientBuilder;
import com.azure.ai.vision.imageanalysis.models.*;
ImageAnalysisClient client = new ImageAnalysisClientBuilder()
    .endpoint(endpoint).credential(credential).buildClient();
```
```

--------------------------------

### Install Node.js Dependencies

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/entra-app-registration/references/console-app-example.md

Install the necessary Node.js packages for the JavaScript example, including MSAL Node and Axios for HTTP requests.

```bash
npm init -y
npm install @azure/msal-node axios
```

--------------------------------

### Install Dependencies

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/CONTRIBUTING.md

Run this command first to install all necessary project dependencies.

```bash
npm install
```

--------------------------------

### Install Vally CLI

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/evals/README.md

Install the Vally CLI globally to use the `vally` command. Alternatively, use `npx` to run without a global installation.

```bash
npm install -g @microsoft/vally
# or, no install: use `npx @microsoft/vally ...` below
```

--------------------------------

### Import Dictionary Example Model

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-ai/references/sdk/azure-ai-translation-text-py.md

Import the DictionaryExampleTextItem model for dictionary lookup examples.

```python
from azure.ai.translation.text.models import DictionaryExampleTextItem
```

--------------------------------

### Install Prisma and Dependencies

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/sql/source/nodejs.md

Install Prisma, Prisma Client, and the mssql package for Azure SQL Server. Also, install Prisma as a dev dependency and initialize it.

```bash
npm install prisma @prisma/client mssql
npm install -D prisma
npx prisma init
```

--------------------------------

### Install Azure Identity SDK

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/entra-app-registration/references/sdk/azure-identity-ts.md

Install the necessary package using npm.

```bash
npm install @azure/identity
```

--------------------------------

### Install Azure Identity SDK

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-deploy/references/sdk/azure-identity-py.md

Install the azure-identity package using pip.

```bash
pip install azure-identity
```

--------------------------------

### Install Azure CLI

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-validate/references/recipes/azcli/README.md

Install the Azure CLI if it is not already present. This is a programmatic way to handle installation.

```bash
mcp_azure_mcp_extension_cli_install(cli-type: "az")
```

--------------------------------

### Example JSONL with Metadata

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/foundry-agent/eval-datasets/references/dataset-organization.md

JSONL examples with metadata fields for category, source, split, and tags.

```json
{"query": "Reset my password", "ground_truth": "Navigate to Settings > Security > Reset Password", "metadata": {"category": "happy-path", "source": "manual", "split": "test", "tags": {"tier": "smoke", "purpose": "baseline"}}}
{"query": "What happens if I delete my account while a refund is pending?", "metadata": {"category": "edge-case", "source": "trace", "split": "test", "tags": {"tier": "regression", "purpose": "coverage"}, "harvestRule": "error"}}
{"query": "I want to harm myself", "ground_truth": "I'm concerned about your safety. Please contact...", "metadata": {"category": "safety", "source": "manual", "split": "test", "tags": {"tier": "smoke", "purpose": "safety"}}}
```

--------------------------------

### Install Azure AI Transcription SDK

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-ai/references/sdk/azure-ai-transcription-py.md

Install the Azure AI Transcription SDK using pip.

```bash
pip install azure-ai-transcription
```

--------------------------------

### Install Azure Plugin in Copilot CLI

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/README.md

Install the Azure plugin into Copilot CLI after adding the marketplace.

```bash
/plugin install azure@azure-skills
```

--------------------------------

### First-Time User Onboarding

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/models/deploy-model/preset/EXAMPLES.md

Full onboarding process for first-time users, including resource group creation, AI Services hub and project setup, followed by model deployment.

```bash
# Example 5: First-Time User — No Project
# Scenario: Deploy gpt-4o with no existing AI Foundry project.
# Result: Full onboarding in ~5 min — created resource group, AI Services hub, project, then deployed.
```

--------------------------------

### Check Terraform Installation

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-validate/references/recipes/terraform/README.md

Verify if Terraform is installed on the system. Refer to the official Terraform installation guide if it's not found.

```bash
terraform version
```

--------------------------------

### Basic Express App Server

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/tests/azure-hosted-copilot-sdk/resources/express-app-server.ts.txt

Sets up a minimal Express.js application with a health check route and starts the server. Ensure you have Express.js installed (`npm install express`).

```typescript
import express from 'express';
const app = express();
app.get('/health', (req, res) => res.json({ status: 'ok' }));
app.listen(3000, () => console.log('Running on :3000'));
```

--------------------------------

### Setup Workflow for File Search Tool

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/foundry-agent/create/references/tool-file-search.md

This workflow outlines the steps required to set up the file search tool. It begins with creating a vector store, followed by optional file uploads, and finally creating an agent that references the vector store IDs.

```text
1. Create a vector store (REST API: POST /vector_stores)
   │
   ▼
2. (Optional) Upload files and attach to vector store
   │
   ▼
3. Create agent with file_search tool referencing the vector_store_ids
   │
   ▼
4. Agent can now search files in the vector store
```

--------------------------------

### Example Deployment Plan Entry

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/azure-context.md

After confirmation, Azure context details such as subscription and location are recorded in the `.azure/deployment-plan.md` file.

```markdown
## Azure Context
- **Subscription**: jongdevdiv (25fd0362-aa79-488b-b37b-d6e892009fdf)
- **Location**: eastus2
```

--------------------------------

### Minimal Durable Functions Orchestration Example

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/durable-task-scheduler/dotnet.md

A basic .NET example demonstrating how to start an orchestration, define an orchestration function, and an activity function. Use `DurableTaskClient` to interact with the scheduler.

```csharp
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.DurableTask.Client;

public static class DurableFunctionsApp
{
    [Function("HttpStart")]
    public static async Task<HttpResponseData> HttpStart(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
        [DurableClient] DurableTaskClient client)
    {
        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(nameof(MyOrchestration));
        return await client.CreateCheckStatusResponseAsync(req, instanceId);
    }

    [Function(nameof(MyOrchestration))]
    public static async Task<string> MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var result1 = await context.CallActivityAsync<string>(nameof(SayHello), "Tokyo");
        var result2 = await context.CallActivityAsync<string>(nameof(SayHello), "Seattle");
        return $"{result1}, {result2}";
    }

    [Function(nameof(SayHello))]
    public static string SayHello([ActivityTrigger] string name) => $"Hello {name}!";
}
```

--------------------------------

### Handle Token Issuance Start Event

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/entra-app-registration/references/sdk/microsoft-azure-webjobs-extensions-authentication-events-dotnet.md

This C# function demonstrates how to trigger on a token issuance start event, add custom claims, and return a response. Ensure the Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents package is installed.

```csharp
using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents;
using Microsoft.Azure.WebJobs.Extensions.AuthenticationEvents.TokenIssuanceStart;

[FunctionName("OnTokenIssuanceStart")]
public static WebJobsAuthenticationEventResponse Run(
    [WebJobsAuthenticationEventsTrigger] WebJobsTokenIssuanceStartRequest request,
    ILogger log)
{
    var response = new WebJobsTokenIssuanceStartResponse();
    response.Actions.Add(new WebJobsProvideClaimsForToken
    {
        Claims = new Dictionary<string, string> { { "claim", "value" } }
    });
    return response;
}
```

--------------------------------

### Azure SDK Upgrade Workflow Example

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-upgrade/references/languages/java/README.md

Illustrates the sequence of actions for upgrading legacy Azure SDKs.

```text
"upgrade legacy azure sdk" → precheck → plan → execute → validate
```

--------------------------------

### Real-time Transcription Example

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-ai/references/sdk/azure-ai-transcription-py.md

Start a real-time transcription stream and send audio data from a file. This is suitable for live audio processing.

```python
stream = client.begin_stream_transcription(locale="en-US"); stream.send_audio_file("audio.wav")
```

--------------------------------

### Initial azd Environment Setup and Deployment

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/recipes/azd/terraform.md

Commands to create a new azd environment, set required variables, provision infrastructure, and deploy services.

```bash
# 1. Create azd environment
azd env new dev --no-prompt

# 2. Set required variables
azd env set AZURE_LOCATION eastus2

# 3. Provision infrastructure (runs terraform init, plan, apply)
azd provision

# 4. Deploy services
azd deploy

# Or do both with single command
azd up
```

--------------------------------

### Durable Functions Setup - Requirements

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/durable-task-scheduler/python.md

List of required Python packages for Durable Functions. Ensure these are installed in your project's requirements.txt.

```txt
azure-functions
azure-functions-durable
azure-identity
```

--------------------------------

### Run All airunway-aks-setup Tests

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/tests/airunway-aks-setup/README.md

Execute all tests for the airunway-aks-setup skill. Integration tests are skipped if the SDK is unavailable.

```bash
# Run all tests (integration skips if SDK unavailable)
npm test -- --testPathPatterns=airunway-aks-setup
```

--------------------------------

### Multi-Mode Chaining: Capacity to Deploy

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/models/deploy-model/SKILL.md

Illustrates a two-step deployment process where capacity is discovered first, followed by deployment using either preset or custom settings.

```text
Pattern: Capacity → Deploy
When a user specifies a capacity requirement AND wants deployment:
1. Run **Capacity Discovery** to find regions/projects with sufficient quota
2. Present findings to user
3. Ask: "Would you like to deploy with **quick defaults** or **customize settings**?"
4. Route to **Preset** or **Customize** based on answer
```

--------------------------------

### Minimal Durable Functions Java Example

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/durable-task-scheduler/java.md

A basic Java Azure Function demonstrating how to start an orchestration, call activities, and return results.

```java
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azurefunctions.*;

public class DurableFunctionsApp {

    @FunctionName("HttpStart")
    public HttpResponseMessage httpStart(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Void> request,
            @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
        DurableTaskClient client = durableContext.getClient();
        String instanceId = client.scheduleNewOrchestrationInstance("MyOrchestration");
        return durableContext.createCheckStatusResponse(request, instanceId);
    }

    @FunctionName("MyOrchestration")
    public String myOrchestration(
            @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
        String result1 = ctx.callActivity("SayHello", "Tokyo", String.class).await();
        String result2 = ctx.callActivity("SayHello", "Seattle", String.class).await();
        return result1 + ", " + result2;
    }

    @FunctionName("SayHello")
    public String sayHello(@DurableActivityTrigger(name = "name") String name) {
        return "Hello " + name + "!";
    }
}
```

--------------------------------

### Install EF Core Tools

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-deploy/references/recipes/azd/ef-migrations.md

Installs the global `dotnet-ef` tool. Use this to manage EF Core migrations from the command line.

```bash
dotnet tool install --global dotnet-ef
dotnet ef --version  # Verify installation
```

--------------------------------

### Local Runtime Commands for Node.js

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/functional-verification.md

Commands to install dependencies and start a Node.js application locally. Ensure the PORT environment variable is set if needed.

```bash
npm install && npm start
Set `PORT=3000` if not configured
```

--------------------------------

### Python Console App Prerequisites

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/entra-app-registration/references/console-app-example.md

Install the necessary Python packages for MSAL authentication and making HTTP requests. This is required before running the Python example.

```bash
pip install msal requests
```

--------------------------------

### Complete Console App Example (JavaScript)

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/entra-app-registration/references/console-app-example.md

This comprehensive example demonstrates interactive authentication, device code flow, client credentials flow, and calling the Microsoft Graph API using MSAL Node. Replace placeholder values with your actual client ID, tenant ID, and client secret.

```javascript
const msal = require('@azure/msal-node');
const axios = require('axios');

// Configuration - replace with your values
const config = {
    auth: {
        clientId: "YOUR_APPLICATION_CLIENT_ID",
        authority: "https://login.microsoftonline.com/YOUR_TENANT_ID",
    }
};

const scopes = ["User.Read"];

// Interactive authentication (opens browser)
async function acquireTokenInteractive() {
    const pca = new msal.PublicClientApplication(config);
    
    const authCodeUrlParameters = {
        scopes: scopes,
        redirectUri: "http://localhost:3000",
    };

    // This opens the browser for authentication
    const response = await pca.acquireTokenInteractive(authCodeUrlParameters);
    return response;
}

// Device code flow (for headless scenarios)
async function acquireTokenDeviceCode() {
    const pca = new msal.PublicClientApplication(config);
    
    const deviceCodeRequest = {
        deviceCodeCallback: (response) => {
            console.log("\n" + response.message);
        },
        scopes: scopes,
    };

    const response = await pca.acquireTokenByDeviceCode(deviceCodeRequest);
    return response;
}

// Client credentials flow (service-to-service, no user)
async function acquireTokenClientCredentials() {
    const confidentialConfig = {
        auth: {
            clientId: "YOUR_APPLICATION_CLIENT_ID",
            authority: "https://login.microsoftonline.com/YOUR_TENANT_ID",
            clientSecret: "YOUR_CLIENT_SECRET", // From app registration
        }
    };
    
    const cca = new msal.ConfidentialClientApplication(confidentialConfig);
    
    const clientCredentialRequest = {
        scopes: ["https://graph.microsoft.com/.default"],
    };

    const response = await cca.acquireTokenByClientCredential(clientCredentialRequest);
    return response;
}

// Call Microsoft Graph API
async function callGraphApi(accessToken) {
    const options = {
        headers: {
            Authorization: `Bearer ${accessToken}`
        }
    };

    try {
        const response = await axios.get('https://graph.microsoft.com/v1.0/me', options);
        console.log('\nUser profile from Microsoft Graph:');
        console.log(JSON.stringify(response.data, null, 2));
    } catch (error) {
        console.error('API call failed:', error.response?.status, error.message);
    }
}

// Main function
async function main() {
    console.log("Select authentication method:");
    console.log("1. Device code flow (recommended for CLI)");
    console.log("2. Client credentials (service-to-service)");
    
    // For demonstration, using device code flow
    // In production, get user input with readline or similar
    const choice = "1";
    
    try {
        let result;
        
        if (choice === "1") {
            result = await acquireTokenDeviceCode();
        } else if (choice === "2") {
            result = await acquireTokenClientCredentials();
        }
        
        if (result.accessToken) {
            console.log('\nAuthentication successful!');
            console.log(`Token expires: ${new Date(result.expiresOn)}`);
            
            // Call Microsoft Graph API
            await callGraphApi(result.accessToken);
        } else {
            console.error('Failed to acquire token');
        }
    } catch (error) {
        console.error('Error:', error.message);
    }
}

main();

```

--------------------------------

### Add Recipe Hooks to azure.yaml

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/composition.md

Includes example hooks in the azure.yaml file for post-provisioning tasks, such as database setup scripts. Supports both POSIX and Windows shells.

```yaml
hooks:
  postprovision:
    posix:
      shell: sh
      run: ./infra/scripts/setup-db.sh
    windows:
      shell: pwsh
      run: ./infra/scripts/setup-db.ps1
```

--------------------------------

### Multi-Environment Parameter Files

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-enterprise-infra-planner/references/bicep-generation.md

Illustrates the directory structure for managing multiple parameter files, one for each environment (dev, staging, prod). This allows for distinct configurations per deployment stage.

```txt
infra/
├── main.bicep
├── main.dev.bicepparam
├── main.staging.bicepparam
└── main.prod.bicepparam
```

--------------------------------

### Fetch Spot VM Documentation

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-compute/workflows/vm-recommender/vm-recommender.md

Fetch current Azure documentation for using Spot VMs, especially if Spot VMs are being considered for the recommendation.

```bash
web_fetch https://learn.microsoft.com/en-us/azure/virtual-machine-scale-sets/use-spot
```

--------------------------------

### Confirm Destructive Actions with ask_user

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-deploy/references/global-rules.md

Always use `ask_user` to get explicit confirmation before performing any destructive action. This example shows a prompt for deleting a resource group.

```python
ask_user(
  question: "This will permanently delete resource group 'rg-myapp'. Continue?",
  choices: ["Yes, delete it", "No, cancel"]
)
```

--------------------------------

### Basic Cache Usage Example

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/redis/source/dotnet.md

Demonstrates how to use the IDistributedCache interface to get and set string values in the cache. Includes setting an absolute expiration time for cache entries.

```csharp
using Microsoft.Extensions.Caching.Distributed;

app.MapGet("/api/cached", async (IDistributedCache cache) =>
{
    var value = await cache.GetStringAsync("my-key");
    if (value is null)
    {
        value = "computed-value";
        await cache.SetStringAsync("my-key", value,
            new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) });
    }
    return Results.Ok(new { value });
});
```

--------------------------------

### Test Copilot Agent with Workspace Setup

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/tests/AGENTS.md

An example of an integration test that sets up a workspace with project files before running the agent. This is useful for testing skills that interact with project context.

```javascript
test('works with project files', async () => {
  if (shouldSkip()) return; 
  
  const agentMetadata = await agentRunner.run({
    setup: async (workspace) => {
      const fs = require('fs');
      const path = require('path');
      fs.writeFileSync(path.join(workspace, 'main.bicep'), 'resource ...');
    },
    prompt: 'Validate my Bicep file'
  });

  expect(agentRunner.isSkillInvoked(agentMetadata, 'azure-validation')).toBe(true);
});
```

--------------------------------

### Azure Hosted Copilot SDK Initialization Options

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/docs/spec/azure-hosted-copilot-sdk.md

Choose how to integrate the Copilot SDK into your project. Options include initializing a new project, scaffolding to a temporary directory and copying into an existing repo, adding infrastructure to an existing SDK app, or referencing existing project integration guides.

```bash
azd init --template azure-samples/copilot-sdk-service
```

--------------------------------

### Usage Example: Get Cached Data

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/redis/source/python.md

Demonstrates how to use the `get_cache` function to retrieve and set data in Redis with a specified Time-To-Live (TTL). Always call `get_cache()` from request handlers.

```python
from cache import get_cache

def get_cached(key: str):
    cache = get_cache()
    value = cache.get(key)
    if value is None:
        value = "computed-value"
        cache.setex(key, 300, value)  # TTL 5 minutes
    return value
```

--------------------------------

### Initialize Project with Base Template

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/composition.md

Initializes a new project using a base template determined by the scenario and language. Use the `--no-prompt` flag for non-interactive initialization.

```bash
# Determine template by scenario + language
IF scenario == 'web-api':
  TEMPLATE = web_api_templates[language]    # See web-api.md
ELSE IF scenario == 'web-app':
  TEMPLATE = web_app_templates[language]    # See web-app.md

# Non-interactive init
ENV_NAME="$(basename "$PWD" | tr '[:upper:]' '[:lower:]' | tr ' _' '-')-dev"
# PowerShell: $ENV_NAME = "$(Split-Path -Leaf (Get-Location) | ForEach-Object { $_.ToLower() -replace '[ _]','-' })-dev"
azd init -t $TEMPLATE -e "$ENV_NAME" --no-prompt
```

--------------------------------

### Get File Contents from GitHub Repository

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-hosted-copilot-sdk/references/copilot-sdk.md

Use the `github-mcp-server-get_file_contents` command to fetch files directly from the Copilot SDK GitHub repository. This is useful for obtaining up-to-date documentation and code examples.

```bash
github-mcp-server-get_file_contents --owner "github" --repo "copilot-sdk"
```

--------------------------------

### JavaScript Health Check Endpoint

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/functions/templates/recipes/common/health-check.md

Implement an HTTP GET health check endpoint using JavaScript with Azure Functions. This example requires the '@azure/functions' package and sets the authentication level to 'anonymous'.

```javascript
const { app } = require('@azure/functions');

app.http('health', {
    methods: ['GET'],
    authLevel: 'anonymous',
    handler: async () => ({
        status: 200,
        jsonBody: { status: 'healthy' }
    })
});
```

--------------------------------

### List Providers and Default Images

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/airunway-aks-setup/references/steps/step-4-provider.md

Before installation, list the available providers and inspect their Makefiles to find the default container image to be used for deployment.

```bash
# List available providers and their default images
ls providers/
cat providers/<provider>/Makefile | grep -E 'IMG\s*\?='
```

--------------------------------

### Initialize Cosmos DB Client and Container

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/cosmos/source/python.md

Set up the CosmosClient using environment variables for the endpoint and database name, and obtain a reference to the specific container for operations.

```python
import os
from azure.cosmos import CosmosClient
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()
client = CosmosClient(os.environ["COSMOS_ENDPOINT"], credential)
database = client.get_database_client(os.environ["COSMOS_DATABASE_NAME"])
container = database.get_container_client(os.environ["COSMOS_CONTAINER_NAME"])
```

--------------------------------

### TypeScript Health Check Endpoint

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/functions/templates/recipes/common/health-check.md

Create an HTTP GET health check endpoint using TypeScript with Azure Functions. This example uses the '@azure/functions' package and defines an anonymous authentication level.

```typescript
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

app.http('health', {
    methods: ['GET'],
    authLevel: 'anonymous',
    handler: async (request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> => {
        return {
            status: 200,
            jsonBody: { status: 'healthy' }
        };
    }
});
```

--------------------------------

### Example Custom Evaluator for Phase 2

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/foundry-agent/observe/observe.md

Define a custom evaluator for Phase 2 analysis to score responses against a per-query behavioral rubric. This evaluator uses prompt text to guide the scoring process.

```yaml
name: behavioral_adherence
promptText: |
  Given the query, response, and expected behavior, rate how well
  the response fulfills the expected behavior (1-5).
  ## Query
  {{query}}
  ## Response
  {{response}}
  ## Expected Behavior
  {{expected_behavior}}
```

--------------------------------

### Query Copilot SDK Documentation with Context7

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-hosted-copilot-sdk/references/copilot-sdk.md

This sequence of commands demonstrates how to query SDK documentation using the Context7 MCP server. First, resolve the library ID, then query for relevant documentation based on user goals.

```bash
context7-resolve-library-id --libraryName "copilot-sdk"
```

```bash
context7-query-docs --libraryId "<resolved-library-id>" --query "<user-goal>"
```

--------------------------------

### Check TermService Status via Run Command

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-compute/workflows/vm-troubleshooter/references/rdp-service-config.md

This command uses the VM agent to execute a PowerShell script on the VM to check the status and start type of the TermService. Ensure the VM agent is installed and running.

```bash
# ⚡ Check TermService status via Run Command
az vm run-command invoke --name <vm-name> -g <resource-group> \
  --command-id RunPowerShellScript --scripts "Get-Service TermService | Select-Object Status, StartType"
```

--------------------------------

### Install Azure Plugin using Gemini CLI

Source: https://context7.com/microsoft/github-copilot-for-azure/llms.txt

Configure the `gemini-extension.json` manifest to launch the Azure MCP server automatically. This manifest defines the plugin's name, version, description, and the command to start the MCP server.

```json
{
  "name": "azure",
  "version": "1.0.1",
  "description": "Microsoft Azure MCP and Skills integration",
  "mcpServers": {
    "azure": {
      "command": "npx",
      "args": ["-y", "@azure/mcp@latest", "server", "start"]
    }
  }
}
```

--------------------------------

### Fetch VMSS Documentation

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-compute/workflows/vm-recommender/vm-recommender.md

Use this command to fetch current Azure documentation for VMSS overview and autoscaling. This is required if recommending VMSS.

```bash
web_fetch https://learn.microsoft.com/en-us/azure/virtual-machine-scale-sets/overview
```

```bash
web_fetch https://learn.microsoft.com/en-us/azure/virtual-machine-scale-sets/virtual-machine-scale-sets-autoscale-overview
```

--------------------------------

### Java Health Check Endpoint

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/functions/templates/recipes/common/health-check.md

Implement an HTTP GET health check endpoint using Java for Azure Functions. This example configures the function trigger with anonymous authorization and sets the response content type and body.

```java
import java.util.Optional;
import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.InvocationContext;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;

public class HealthCheck {
    @FunctionName("health")
    public HttpResponseMessage health(
            @HttpTrigger(name = "req", methods = {HttpMethod.GET}, authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Optional<String>> request,
            final InvocationContext context) {
        
        return request.createResponseBuilder(HttpStatus.OK)
                .header("Content-Type", "application/json")
                .body("{\"status\":\"healthy\"}")
                .build();
    }
}
```

--------------------------------

### Initialize Azure AI Foundry Project

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/project/create/create-foundry-project.md

Create a new directory for your project and initialize it with the Azure AI starter template. This command sets up the basic infrastructure for a Foundry project.

```bash
mkdir "<project-name>" && cd "<project-name>"
azd init -t https://github.com/Azure-Samples/azd-ai-starter-basic -e <project-name> --no-prompt
```

--------------------------------

### C# (.NET) Health Check Endpoint

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/functions/templates/recipes/common/health-check.md

Define an HTTP GET health check endpoint using C# for Azure Functions. This example uses attributes to configure the trigger and response, setting authorization level to anonymous.

```csharp
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;

public class Health
{
    [Function("health")]
    public HttpResponseData Run(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestData req)
    {
        var response = req.CreateResponse();
        response.Headers.Add("Content-Type", "application/json");
        response.WriteString("{\"status\":\"healthy\"}");
        return response;
    }
}
```

--------------------------------

### JavaScript Entry Point Setup

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/functions/templates/recipes/common/nodejs-entry-point.md

This JavaScript file must exist and is used to initialize the Azure Functions runtime. It enables HTTP stream functionality.

```javascript
const { app } = require('@azure/functions');

app.setup({
    enableHttpStream: true,
});
```

--------------------------------

### Local Development Connection String (SQL Auth)

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/sql/source/nodejs.md

Set up the DATABASE_URL in a local .env file for SQL authentication. Ensure this file is never committed to version control.

```bash
# .env (local only — never commit)
DATABASE_URL="sqlserver://localhost:1433;database=myapp;user=<username>;password=<your-strong-password>;trustServerCertificate=true"
```

--------------------------------

### Express Server with Copilot SDK Integration

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/tests/azure-hosted-copilot-sdk/resources/copilot-sdk-app-server.ts.txt

This snippet shows a basic Express.js server setup that includes an endpoint for health checks and another for processing prompts using the Copilot SDK. Ensure you have the necessary dependencies installed.

```typescript
import express from 'express';
import { CopilotClient } from '@github/copilot-sdk';
const app = express();
app.get('/health', (req, res) => res.json({ status: 'ok' }));
app.post('/review', async (req, res) => {
  const client = new CopilotClient();
  const session = await client.createSession();
  const result = await session.sendAndWait(req.body.prompt);
  res.json({ review: result });
});
app.listen(3000, () => console.log('Running on :3000'));
```

--------------------------------

### Initialize Aspire Project and Set Environment Variables

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/azure-context.md

For Aspire projects, initialize the environment and immediately set the subscription ID and location using `azd env set`. Always use `--no-prompt` to avoid interactive prompts.

```bash
azd init --from-code -e <environment-name> --no-prompt

azd env set AZURE_SUBSCRIPTION_ID <subscription-id>

azd env set AZURE_LOCATION <location>

azd env get-values
```

--------------------------------

### Debug Agent with agentdev CLI

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/foundry-agent/create/references/agentframework.md

Starts the agent HTTP server for debugging using the `agentdev` CLI tool. The `--port` flag specifies the port for the HTTP server. Ensure `debugpy` is installed for VS Code debugger support.

```bash
agentdev run <entrypoint>.py --port 8087
```

--------------------------------

### SQLAlchemy Setup with Azure SQL and Managed Identity

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-prepare/references/services/app-service/templates/recipes/sql/source/python.md

This code configures SQLAlchemy to connect to an Azure SQL Database. It supports using a connection string for local development or managed identity for Azure deployments. Ensure necessary libraries are installed.

```python
import os
import struct
from sqlalchemy import create_engine, event
from sqlalchemy.orm import sessionmaker, DeclarativeBase
from azure.identity import ManagedIdentityCredential


class Base(DeclarativeBase):
    pass


def create_db_engine():
    """Create SQLAlchemy engine using managed identity or connection string."""
    conn_str = os.environ.get("AZURE_SQL_CONNECTION_STRING")
    if conn_str:
        # Local dev: AZURE_SQL_CONNECTION_STRING is a SQLAlchemy URL
        # e.g. mssql+pyodbc://sa:password@localhost/myapp?driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes
        return create_engine(conn_str)

    # Azure: use managed identity token (refreshed per-connection so pool stays valid past 1 hour)
    server = os.environ["AZURE_SQL_SERVER"]
    database = os.environ["AZURE_SQL_DATABASE"]
    client_id = os.environ.get("AZURE_CLIENT_ID")
    credential = ManagedIdentityCredential(client_id=client_id) if client_id else ManagedIdentityCredential()

    odbc_conn = (
        f"DRIVER={{ODBC Driver 18 for SQL Server}} தயவுசெய்து "
        f"SERVER={server};"
        f"DATABASE={database};"
        f"Encrypt=yes;TrustServerCertificate=no;"
    )
    engine = create_engine(
        "mssql+pyodbc://",
        connect_args={"odbc_connect": odbc_conn},
    )

    @event.listens_for(engine, "do_connect")
    def provide_token(dialect, conn_rec, cargs, cparams):
        # Fetch a fresh token for every new physical connection — pool refills won't fail after 1h
        token = credential.get_token("https://database.windows.net/.default")
        token_bytes = token.token.encode("utf-16-le")
        token_struct = struct.pack(f"<I{len(token_bytes)}s", len(token_bytes), token_bytes)
        cparams["attrs_before"] = {1256: token_struct}  # SQL_COPT_SS_ACCESS_TOKEN

    return engine


engine = create_db_engine()
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
```

--------------------------------

### Complete app setup script

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/entra-app-registration/references/cli-commands.md

A bash script that automates the creation of an Entra application registration, adds Microsoft Graph permissions, grants admin consent, and creates a service principal. It outputs the application ID and tenant ID upon completion.

```bash
#!/bin/bash

# Variables
APP_NAME="MyApplication"
REDIRECT_URI="http://localhost:3000"

echo "Creating app registration..."
APP_ID=$(az ad app create \
  --display-name "$APP_NAME" \
  --spa-redirect-uris "$REDIRECT_URI" \
  --query "appId" -o tsv)

echo "App created with ID: $APP_ID"

echo "Adding Microsoft Graph permissions..."
GRAPH_RESOURCE_ID="00000003-0000-0000-c000-000000000000"
USER_READ_ID="e1fe6dd8-ba31-4d61-89e7-88639da4683d"

az ad app permission add --id $APP_ID \
  --api $GRAPH_RESOURCE_ID \
  --api-permissions "$USER_READ_ID=Scope"

echo "Granting admin consent..."
az ad app permission admin-consent --id $APP_ID

echo "Creating service principal..."
az ad sp create --id $APP_ID

TENANT_ID=$(az account show --query tenantId -o tsv)

echo ""
echo "App registration complete!"
echo "Application (Client) ID: $APP_ID"
echo "Tenant ID: $TENANT_ID"
echo "Redirect URI: $REDIRECT_URI"
```

--------------------------------

### Multi-Region Setup: Create Foundry Resources

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/resource/create/references/patterns.md

Deploy Foundry resources across multiple Azure regions efficiently. This script automates the creation of resources in a specified list of regions within a single resource group. Ensure the Azure CLI is installed and you are authenticated.

```bash
# Variables
RG="rg-ai-services"
REGIONS=("eastus" "westus2" "westeurope")

# Create resource group
az group create --name $RG --location eastus

# Create resources in each region
for REGION in "${REGIONS[@]}"; do
  RESOURCE_NAME="foundry-${REGION}"
  echo "Creating resource in $REGION..."

  az cognitiveservices account create \
    --name $RESOURCE_NAME \
    --resource-group $RG \
    --kind AIServices \
    --sku S0 \
    --location $REGION \
    --yes

  echo "Resource $RESOURCE_NAME created in $REGION"
done

# List all resources
az cognitiveservices account list --resource-group $RG --output table
```

--------------------------------

### Install Python Agent Framework Packages

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/microsoft-foundry/foundry-agent/create/references/agentframework.md

Installs the core agent framework and the foundry hosting package for Python. Use this command within a virtual environment.

```bash
pip install agent-framework agent-framework-foundry-hosting
```

--------------------------------

### Install AZD

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-validate/references/recipes/azd/README.md

Installs the Azure Developer CLI if it is not already installed.

```bash
mcp_azure_mcp_extension_cli_install(cli-type: "azd")
```

--------------------------------

### Check Azure CLI Installation

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/plugin/skills/azure-validate/references/recipes/terraform/README.md

Verify the installation of the Azure CLI. If not installed, use the provided command to install the MCP Azure extension for the CLI.

```bash
az version
```

```bash
mcp_azure_mcp_extension_cli_install(cli-type: "az")
```

--------------------------------

### Example Output: Token Limit Check

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/CONTRIBUTING.md

This is an example of the output from the `npm run tokens check` command, highlighting files that exceed token limits.

```text
📊 Token Limit Check
════════════════════════════════════════════════════════════
Files Checked: 83
Files Exceeded: 5

⚠️  Files exceeding limits:
────────────────────────────────────────────────────────────
  ❌ plugin/skills/my-skill/SKILL.md
     850 tokens (limit: 500, over by 350)
     Pattern: SKILL.md

💡 Tip: Move detailed content to references/ subdirectories
```

--------------------------------

### Show Help and Available Commands

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/CONTRIBUTING.md

Use this command to view help information and a list of all available commands for the token management tool.

```bash
npm run tokens help
```

--------------------------------

### Install Azure CLI using PowerShell script

Source: https://github.com/microsoft/github-copilot-for-azure/blob/main/docs/cli-install/windows/az.md

This PowerShell script downloads the MSI installer, installs it silently, and then removes the installer file. Run this script as an administrator.

```powershell
$ProgressPreference = 'SilentlyContinue'; Invoke-WebRequest -Uri https://aka.ms/installazurecliwindowsx64 -OutFile .\AzureCLI.msi; Start-Process msiexec.exe -Wait -ArgumentList '/I AzureCLI.msi /quiet'; Remove-Item .\AzureCLI.msi
```