System Prompts and Models of AI Tools

https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools
Admin
A comprehensive collection of system prompts, tools, and AI models from various AI applications and...
Tokens:295,934
Snippets:2,378
Trust Score:7.3
License:GPL-3.0
Update:7 months ago
Show doc for...
Tokens:
Raw
### Execute npm install command

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Anthropic/Claude Code 2.0.txt

Demonstrates the execution of the 'npm install' command, typically used in Node.js projects to install project dependencies. This example shows a direct command execution without complex logic.

```bash
npm install
```

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

### Live API Function Calling Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Google/Gemini/AI Studio vibe-coder.txt

This example demonstrates how to set up the Live API with function declarations and handle function calls and responses within the `onmessage` callback.

```APIDOC
## POST /v1/models/gemini-2.5-flash-native-audio-preview-09-2025:streamGenerateContent

### Description
This endpoint supports function calling, allowing the AI model to invoke predefined functions with specified arguments and receive results back to continue the conversation.

### Method
POST

### Endpoint
`/v1/models/gemini-2.5-flash-native-audio-preview-09-2025:streamGenerateContent`

### Parameters
#### Request Body
- **model** (string) - Required - The model to use for generation (e.g., 'gemini-2.5-flash-native-audio-preview-09-2025').
- **config** (object) - Required - Configuration for the generation.
  - **responseModalities** (array) - Required - Must contain `Modality.AUDIO`.
  - **tools** (array) - Required - An array of tool configurations.
    - **functionDeclarations** (array) - Required - An array of function declarations.
      - **name** (string) - Required - The name of the function.
      - **parameters** (object) - Required - The schema for the function's parameters.
        - **type** (string) - Required - The type of the parameter object (e.g., 'OBJECT').
        - **description** (string) - Required - A description of the function's purpose.
        - **properties** (object) - Required - An object defining the function's arguments.
          - **[argument_name]** (object) - Optional - Description of an argument.
            - **type** (string) - Required - The data type of the argument (e.g., 'NUMBER', 'STRING').
            - **description** (string) - Required - Description of the argument.
        - **required** (array) - Optional - An array of argument names that are required.

### Request Example
```typescript
import { FunctionDeclaration,  GoogleGenAI, LiveServerMessage, Modality, Type } from '@google/genai';

const controlLightFunctionDeclaration: FunctionDeclaration = {
  name: 'controlLight',
  parameters: {
    type: Type.OBJECT,
    description: 'Set the brightness and color temperature of a room light.',
    properties: {
      brightness: {
        type: Type.NUMBER,
        description:
          'Light level from 0 to 100. Zero is off and 100 is full brightness.',
      },
      colorTemperature: {
        type: Type.STRING,
        description:
          'Color temperature of the light fixture such as `daylight`, `cool` or `warm`.',
      },
    },
    required: ['brightness', 'colorTemperature'],
  },
};

const sessionPromise = ai.live.connect({
  model: 'gemini-2.5-flash-native-audio-preview-09-2025',
  callbacks: {
    onopen: () => {
      console.debug('opened');
    },
    onmessage: async (message: LiveServerMessage) => {
      if (message.toolCall) {
        for (const fc of message.toolCall.functionCalls) {
          console.debug('function call: ', fc);
          // Assume you have executed your function:
          // const result = await controlLight(fc.args.brightness, fc.args.colorTemperature);
          const result = "ok"; // Return a simple confirmation
          sessionPromise.then((session) => {
            session.sendToolResponse({
              functionResponses: {
                id : fc.id,
                name: fc.name,
                response: { result: result },
              },
            });
          });
        }
      }
      const base64EncodedAudioString = message.serverContent?.modelTurn?.parts[0]?.inlineData.data;
      if (base64EncodedAudioString) {
        /* ... process the audio output ... */
      }
    },
    onerror: (e: ErrorEvent) => {
      console.debug('got error');
    },
    onclose: (e: CloseEvent) => {
      console.debug('closed');
    },
  },
  config: {
    responseModalities: [Modality.AUDIO],
    tools: [{functionDeclarations: [controlLightFunctionDeclaration]}],
  },
});
```

### Response
#### Success Response (200)
- **toolCall** (object) - Contains information about function calls requested by the model.
  - **functionCalls** (array) - An array of function call objects.
    - **id** (string) - Unique identifier for the function call.
    - **name** (string) - The name of the function to be called.
    - **args** (object) - The arguments to be passed to the function.
- **serverContent** (object) - Contains server-generated content, potentially including audio data.
  - **modelTurn** (object) - Represents a turn from the model.
    - **parts** (array) - An array of content parts.
      - **inlineData** (object) - Contains inline data, such as base64 encoded audio.
        - **data** (string) - Base64 encoded data.

#### Response Example
```json
{
  "toolCall": {
    "functionCalls": [
      {
        "id": "functionCall-id-123",
        "name": "controlLight",
        "args": {
          "brightness": 25,
          "colorTemperature": "warm"
        }
      }
    ]
  }
}
```

#### Error Handling
- **ErrorEvent**: The `onerror` callback will receive an `ErrorEvent` object containing details about the error.
```

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

### MCP Configuration Example (JSON)

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Kiro/Spec_Prompt.txt

An example JSON structure for an MCP configuration file, demonstrating server definitions, command execution, arguments, environment variables, and auto-approval settings.

```json
{
  "mcpServers": {
    "aws-docs": {
        "command": "uvx",
        "args": ["awslabs.aws-documentation-mcp-server@latest"],
        "env": {
          "FASTMCP_LOG_LEVEL": "ERROR"
        },
        "disabled": false,
        "autoApprove": []
    }
  }
}
```

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

### MCP Configuration Example (JSON)

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Kiro/Vibe_Prompt.txt

An example JSON structure for configuring MCP servers. This includes server definitions, command arguments, environment variables, and approval settings. It demonstrates how to specify server details and manage their state.

```json
{
 "mcpServers": {
   "aws-docs": {
       "command": "uvx",
       "args": ["awslabs.aws-documentation-mcp-server@latest"],
       "env": {
         "FASTMCP_LOG_LEVEL": "ERROR"
       },
       "disabled": false,
       "autoApprove": []
   }
 }
}

```

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

### Usage Examples from Customer Data (TypeScript)

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Orchids.app/System Prompt.txt

Shows practical examples of how to access and display customer data, such as the current plan name and usage meter, using optional chaining and template literals. It also demonstrates how to check for specific product ownership.

```typescript
// Current plan: customer?.products[0]?.name || "Free Plan"
// Usage meter: `${usage} / ${included_usage}`
// Check access: customer.products.find(p => p.id === "pro")

// Example usage within a component:
// const PlanDisplay = ({ customer }) => {
//   return <div>Current plan: {customer?.products[0]?.name || "Free Plan"}</div>;
// };

// const UsageIndicator = ({ feature }) => {
//   if (!feature) return null;
//   return <div>Usage: {feature.usage} / {feature.included_usage}</div>;
// };

// const ProAccessCheck = ({ customer }) => {
//   const hasPro = customer?.products.some(p => p.id === "pro");
//   return <div>Has Pro Plan: {hasPro ? "Yes" : "No"}</div>;
// };
```

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

### Code Display Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Augment Code/gpt-5-agent-prompts.txt

An example of how to display code snippets using XML tags with path and mode attributes, as specified for showing code from existing files.

```xml
<augment_code_snippet path="foo/bar.py" mode="EXCERPT">
```python
class AbstractTokenizer():
    def __init__(self, name):
        self.name = name
    ...
```
</augment_code_snippet>
```

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

### Example: Create Users Table Migration

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Open Source prompts/Bolt/Prompt.txt

An example illustrating the creation of a 'users' table, including its schema definition and the necessary Supabase actions for migration and query execution. This showcases the structure within a boltArtifact.

```xml
<boltArtifact id="create-users-table" title="Create Users Table">
  <boltAction type="supabase" operation="migration" filePath="/supabase/migrations/create_users.sql">
    CREATE TABLE users (
      id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
      email text UNIQUE NOT NULL
    );
  </boltAction>

  <boltAction type="supabase" operation="query" projectId="${projectId}">
    CREATE TABLE users (
      id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
      email text UNIQUE NOT NULL
    );
  </boltAction>
</boltArtifact>
```

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

### Tool Parameter Formatting Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Google/Antigravity/Fast Prompt.txt

Demonstrates the correct JSON structure for passing array or object parameters to tools. This example shows how to format a parameter named 'parameter' with an array of objects, each containing nested options.

```json
<function_calls>
<invoke name="example_complex_tool">
<parameter name="parameter">[{"color": "orange", "options": {"option_key_1": true, "option_key_2": "value"}}, {"color": "purple", "options": {"option_key_1": true, "option_key_2": "value"}}]</parameter>
</invoke>
</function_calls>
```

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

### shadcn/ui Component File Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Same.dev/Prompt.txt

Example of a shadcn/ui component file, typically located in the `components/ui` directory. These components should always be customized to align with user preferences and application design.

```typescript
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { cva, type VariantProps } from "class-variance-authority"

import { cn } from "@/lib/utils"

export const buttonVariants = cva(
  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
  {
    variants: {
      variant: {
        default: "bg-primary text-primary-foreground hover:bg-primary/90",
        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
        ghost: "hover:bg-accent hover:text-accent-foreground",
        link: "text-primary underline-offset-4 hover:underline",
      },
      size: {
        default: "h-10 px-4 py-2",
        sm: "h-9 rounded-md px-3",
        lg: "h-11 rounded-md px-8",
        icon: "h-10 w-10",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
)

export interface ButtonProps
  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
    VariantProps<typeof buttonVariants> {
  asChild?: boolean
}

const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
  ({ className, variant, size, asChild = false, ...props }, ref) => {
    const Comp = asChild ? Slot : "button"
    return (
      <Comp
        className={cn(buttonVariants({ variant, size, className }))}
        ref={ref}
        {...props}
      />
    )
  }
)
Button.displayName = "Button"

export { Button, buttonVariants }

```

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

### Customer Data Structure Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Orchids.app/System Prompt.txt

Provides an example of the customer data structure returned by the `useCustomer` hook. This structure includes details about the customer's account, products, and feature usage, which can be used for displaying plan information and usage meters.

```json
{
  "created_at": 1677649423000,
  "env": "production",
  "id": "user_123",
  "name": "John Yeo",
  "email": "john@example.com",
  "fingerprint": "",
  "stripe_id": "cus_abc123",
  "products": [
    {
      "id": "pro",
      "name": "Pro Plan",
      "group": "",
      "status": "active", // or "past_due", "canceled", "trialing"
      "started_at": 1677649423000,
      "canceled_at": null,
      "subscription_ids": ["sub_123"],
      "current_period_start": 1677649423000,
      "current_period_end": 1680327823000
    }
  ],
  "features": {
    "messages": {
      "feature_id": "messages",
      "unlimited": false,
      "interval": "month",
      "balance": 80,          // Remaining
      "usage": 20,            // Current
      "included_usage": 100,  // Total
      "next_reset_at": 1680327823000
    }
  }
}
```

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

### Get Project Setup Information for VS Code

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/VSCode Agent/Prompt.txt

Retrieves project setup information for a VS Code workspace based on project type and programming language. This tool should only be called after a workspace has been created. Supported languages include 'javascript', 'typescript', 'python', and 'other'. Supported project types include 'basic', 'mcp-server', 'model-context-protocol-server', 'vscode-extension', 'next-js', 'vite', and 'other'.

```json
{
  "name": "get_project_setup_info",
  "description": "Do not call this tool without first calling the tool to create a workspace. This tool provides a project setup information for a Visual Studio Code workspace based on a project type and programming language.",
  "parameters": {
    "type": "object",
    "properties": {
      "language": {
        "type": "string",
        "description": "The programming language for the project. Supported: 'javascript', 'typescript', 'python' and 'other'."
      },
      "projectType": {
        "type": "string",
        "description": "The type of project to create. Supported values are: 'basic', 'mcp-server', 'model-context-protocol-server', 'vscode-extension', 'next-js', 'vite' and 'other'"
      }
    },
    "required": ["projectType"]
  }
}
```

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

### Example Codebase Search Query

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Cursor Prompts/Agent Prompt 2.0.txt

This example demonstrates a strategic approach to using `codebase_search`. It begins with a broad query to understand the overall authentication flow and then refines the search to a specific directory based on the initial results to find where user roles are checked.

```json
{
  "query": "How does user authentication work?",
  "target_directories": [],
  "explanation": "Find auth flow"
}
{
  "query": "Where are user roles checked?",
  "target_directories": ["backend/auth/"],
  "explanation": "Find role logic"
}
```

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

### Swift Testing Framework Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Xcode/System.txt

Demonstrates the usage of the Swift Testing framework for writing unit tests. It includes examples of basic assertions and handling optional unwrapping within tests. This framework is preferred for testing in Swift projects.

```swift
import Testing

// Optional, you can also just say `@Suite` with no parentheses.
@Suite("You can put a test suite name here, formatted as normal text.")
struct AddingTwoNumbersTests {

    @Test("Adding 3 and 7")
    func add3And7() async throws {
          let three = 3
        let seven = 7

        // All assertions are written as "expect" statements now.
        #expect(three + seven == 10, "The sums should work out.")
    }

    @Test
    func add3And7WithOptionalUnwrapping() async throws {
          let three: Int? = 3
        let seven = 7

        // Similar to `XCTUnwrap`
        let unwrappedThree = try #require(three)

        let sum = three + seven

        #expect(sum == 10)
    }

}
```

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

### Load MCP Server Documentation

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Open Source prompts/Cline/Prompt.txt

Loads documentation related to creating MCP servers. This tool is used when a user requests to create or install an MCP server, which can provide tools and resources connecting to external APIs. The documentation covers setup, best practices, and examples for the MCP server creation process.

```xml
<load_mcp_documentation>
</load_mcp_documentation>
```

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

### Example API Endpoint Definition

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Leap.new/Prompts.txt

An example demonstrating how to define a 'GET' API endpoint for fetching a todo item. It includes TypeScript interfaces for parameters and the response, and specifies the HTTP method and path.

```typescript
import { api } from "encore.dev/api";

interface GetTodoParams {
  id: number;
}

interface Todo {
  id: number;
  title: string;
  done: boolean;
}

export const get = api<TodoParams, Todo>(
  { expose: true, method: "GET", path: "/todo/:id" },
  async (params) => {
    // ...
  }
);

```

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

### Get Terminal Output

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/VSCode Agent/Prompt.txt

Retrieves the output of a previously started background terminal command.

```APIDOC
## POST /get_terminal_output

### Description
Gets the output of a terminal command previously started with `run_in_terminal`.

### Method
POST

### Endpoint
/get_terminal_output

### Parameters
#### Request Body
- **id** (string) - Required - The ID of the terminal command output to check.

### Request Example
```json
{
  "id": "some_terminal_id"
}
```

### Response
#### Success Response (200)
- **output** (string) - The output of the terminal command.
- **done** (boolean) - Indicates if the background process has finished.

#### Response Example
```json
{
  "output": "Build successful.",
  "done": true
}
```
```

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

### Generate Content with System Instruction and Model Configs

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Google/Gemini/AI Studio vibe-coder.txt

This example demonstrates how to configure advanced model parameters, including a system instruction, when generating content. It shows how to set `topK`, `topP`, `temperature`, `responseMimeType`, and `seed` for fine-tuned model behavior.

```typescript
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.API_KEY });
const response = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  contents: "Tell me a story.",
  config: {
    systemInstruction: "You are a storyteller for kids under 5 years old.",
    topK: 64,
    topP: 0.95,
    temperature: 1,
    responseMimeType: "application/json",
    seed: 42,
  },
});
console.log(response.text);
```

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

### Get Terminal Command Output

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/VSCode Agent/Prompt.txt

Retrieves the output of a terminal command previously started with `run_in_terminal`. Requires the ID of the terminal command.

```json
{
  "name": "get_terminal_output",
  "description": "Get the output of a terminal command previous started with run_in_terminal",
  "parameters": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "description": "The ID of the terminal command output to check."
      }
    },
    "required": ["id"]
  }
}
```

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

### Python Hello World Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Cursor Prompts/Agent Prompt v1.2.txt

Demonstrates a simple 'Hello World' print statement in Python. This is a trivial task suitable for direct execution without complex task management.

```python
print("Hello World")
```

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

### Fetch Task Instructions

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Open Source prompts/RooCode/Prompt.txt

Retrieves instructions for performing a specific task. Currently supports 'create_mcp_server' and 'create_mode'.

```xml
<fetch_instructions>
<task>create_mcp_server</task>
</fetch_instructions>
```

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

### GET /todo/:id

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Leap.new/Prompts.txt

Retrieves a specific todo item by its ID. This endpoint is exposed publicly and uses the GET HTTP method.

```APIDOC
## GET /todo/:id

### Description
Retrieves a specific todo item by its ID.

### Method
GET

### Endpoint
/todo/:id

### Parameters
#### Path Parameters
- **id** (number) - Required - The unique identifier of the todo item.

### Request Example
```json
{
  "id": 123
}
```

### Response
#### Success Response (200)
- **id** (number) - The unique identifier of the todo item.
- **title** (string) - The title of the todo item.
- **done** (boolean) - Indicates whether the todo item is completed.

#### Response Example
```json
{
  "id": 123,
  "title": "Buy groceries",
  "done": false
}
```
```

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

### Mermaid Diagram Generation Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Qoder/prompt.txt

This example demonstrates the basic syntax for generating Mermaid diagrams, focusing on nodes and relationships without any styling elements. It's suitable for representing simple workflows or structures.

```mermaid
graph TB
    A[Login] --> B[Dashboard]
    B --> C[Settings]
```

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

### Connect Project to Custom Domain (Netlify)

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Same.dev/Prompt.txt

Instructions for connecting a project to a custom domain using Netlify. This involves accessing the 'Deployed' panel and clicking 'Claim Deployment' to link the project to a Netlify account for deployment management.

```text
If user wants to connect their project to a custom domain, ask them to open the "Deployed" panel on the top right of their screen, then click on the "Claim Deployment" button to connect the project to their Netlify account. They can perform any deployment management actions from there. You will continue to have access to update the deployment.
```

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

### Fetch Instructions API

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Open Source prompts/RooCode/Prompt.txt

Fetches instructions for a given task. Supports tasks like creating an MCP server or a mode.

```APIDOC
## fetch_instructions

### Description
Request to fetch instructions to perform a task

### Parameters
#### Query Parameters
- **task** (string) - Required - The task to get instructions for. This can take the following values: `create_mcp_server`, `create_mode`.

### Request Example
```xml
<fetch_instructions>
<task>create_mcp_server</task>
</fetch_instructions>
```

### Response
#### Success Response (200)
- **instructions** (string) - The instructions for the specified task.

#### Response Example
```json
{
  "instructions": "Follow these steps to create an MCP server..."
}
```
```

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

### Generate Video from Text Prompt and Starting Image

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Google/Gemini/AI Studio vibe-coder.txt

Generates a video from a text prompt and a starting image. The image is provided as a base64 encoded string with its MIME type. Supports 720p resolution and 9:16 aspect ratio.

```typescript
let operation = await ai.models.generateVideos({
  model: 'veo-3.1-fast-generate-preview',
  prompt: 'A neon hologram of a cat driving at top speed', // prompt is optional
  image: {
    imageBytes: base64EncodeString, // base64 encoded string
    mimeType: 'image/png', // Could be any other IANA standard MIME type for the source data.
  },
  config: {
    numberOfVideos: 1,
    resolution: '720p',
    aspectRatio: '9:16',
  },
});
while (!operation.done) {
  await new Promise(resolve => setTimeout(resolve, 10000));
  operation = await ai.operations.getVideosOperation({operation: operation});
}
const downloadLink = operation.response?.generatedVideos?.[0]?.video?.uri;
// The response.body contains the MP4 bytes. You must append an API key when fetching from the download link.
const response = await fetch(`${downloadLink}&key=${process.env.API_KEY}`);
```

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

### Real-time Audio Transcription with AI Model (TypeScript)

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Google/Gemini/AI Studio vibe-coder.txt

This example shows how to set up a real-time connection to an AI model to enable audio transcription for both user input and model output. It configures the session with `inputAudioTranscription` and `outputAudioTranscription` options and handles incoming transcription text within the `onmessage` callback. It also includes basic error and close event handling.

```typescript
import {GoogleGenAI, LiveServerMessage, Modality} from '@google/genai';

let currentInputTranscription = '';
let currentOutputTranscription = '';
const transcriptionHistory = [];
const sessionPromise = ai.live.connect({
  model: 'gemini-2.5-flash-native-audio-preview-09-2025',
  callbacks: {
    onopen: () => {
      console.debug('opened');
    },
    onmessage: async (message: LiveServerMessage) => {
      if (message.serverContent?.outputTranscription) {
        const text = message.serverContent.outputTranscription.text;
        currentOutputTranscription += text;
      } else if (message.serverContent?.inputTranscription) {
        const text = message.serverContent.inputTranscription.text;
        currentInputTranscription += text;
      }
      // A turn includes a user input and a model output.
      if (message.serverContent?.turnComplete) {
        // You can also stream the transcription text as it arrives (before `turnComplete`)
        // to provide a smoother user experience.
        const fullInputTranscription = currentInputTranscription;
        const fullOutputTranscription = currentOutputTranscription;
        console.debug('user input: ', fullInputTranscription);
        console.debug('model output: ', fullOutputTranscription);
        transcriptionHistory.push(fullInputTranscription);
        transcriptionHistory.push(fullOutputTranscription);
        // IMPORTANT: If you store the transcription in a mutable reference (like React's `useRef`),
        // copy its value to a local variable before clearing it to avoid issues with asynchronous updates.
        currentInputTranscription = '';
        currentOutputTranscription = '';
      }
      // IMPORTANT: You must still handle the audio output.
      const base64EncodedAudioString =
        message.serverContent?.modelTurn?.parts[0]?.inlineData.data;
      if (base64EncodedAudioString) {
        /* ... process the audio output (see Session Setup example) ... */
      }
    },
    onerror: (e: ErrorEvent) => {
      console.debug('got error');
    },
    onclose: (e: CloseEvent) => {
      console.debug('closed');
    },
  },
  config: {
    responseModalities: [Modality.AUDIO], // Must be an array with a single `Modality.AUDIO` element.
    outputAudioTranscription: {}, // Enable transcription for model output audio.
    inputAudioTranscription: {}, // Enable transcription for user input audio.
  },
});
```

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

### Open URL in Web Browser

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/CodeBuddy Prompts/Craft Prompt.txt

Opens a specified web address in the default web browser. This tool requires a valid URL (starting with http:// or https://) and is used to start or preview web content.

```xml
<openweb>
<url>Your URL if you have start a server</url>
</openweb>
```

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

### Create Supabase Migration and Execute Query

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Open Source prompts/Bolt/Prompt.txt

This snippet demonstrates the required two-step process for database changes in Supabase: creating a migration file and executing the same SQL as an immediate query. It ensures consistency between the migration history and the live database state.

```xml
<boltAction type="supabase" operation="migration" filePath="/supabase/migrations/your_migration.sql">
  /* SQL migration content */
</boltAction>

<boltAction type="supabase" operation="query" projectId="${projectId}">
  /* Same SQL content as migration */
</boltAction>
```

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

### Initialize Vite App using npx

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Google/Antigravity/planning-mode.txt

Command to initialize a new web application using Vite. It uses `npx -y` to automatically install the script and dependencies, runs with `--help` to show options, initializes in the current directory, and runs in non-interactive mode.

```bash
npx -y create-vite-app@latest ./ --help
npx -y create-vite-app@latest ./
```

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

### TypeScript Function Reference Example

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/Cursor Prompts/Agent Prompt 2.0.txt

An example of referencing existing TypeScript code, adhering to the `startLine:endLine:filepath` format without a language tag. This is used when pointing to specific lines within an existing file.

```typescript
12:15:src/utils.ts
export function helper() {
  return true;
}
```

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

### Install VS Code Extension

Source: https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/blob/main/VSCode Agent/Prompt.txt

Installs a specified extension in Visual Studio Code. This tool is intended for use only during the new workspace creation process. Requires the extension's ID (in the format <publisher>.<extension>) and its name.

```json
{
  "name": "install_extension",
  "description": "Install an extension in VS Code. Use this tool to install an extension in Visual Studio Code as part of a new workspace creation process only.",
  "parameters": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "description": "The ID of the extension to install. This should be in the format <publisher>.<extension>."
      },
      "name": {
        "type": "string",
        "description": "The name of the extension to install. This should be a clear and concise description of the extension."
      }
    },
    "required": ["id", "name"]
  }
}
```
Tokens:
Raw