Gemini Skills

https://github.com/google-gemini/gemini-skills
Admin
A library of reusable skills for the Gemini API that provides best practices and tools for...
Tokens:79,258
Snippets:513
Trust Score:9.4
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### prep_video.py CLI usage examples

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Example CLI invocations of prep_video.py: defaults, a custom trim start and output, an explicit fps and resolution, and stripping audio. The --start flag in the second example uses a timestamp format.

```bash
./scripts/video/prep_video.py path/to/source.mp4
./scripts/video/prep_video.py path/to/source.mp4 --start 00:03 --output media/custom.mp4
./scripts/video/prep_video.py path/to/source.mp4 --start last --fps 30 --resolution 1920x1080
./scripts/video/prep_video.py path/to/source.mp4 --strip-audio

```

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

### Prompt with source and reference declarations (image reference)

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Example prompt that declares a starting frame source and an image reference, then instructs the model to use Image1 as the starting frame and Image2 as a reference. Use this pattern for complex prompts with multiple media inputs.

```text
[# Sources <FIRST_FRAME>@Image1] [# References <IMAGE_REF_0>@Image2] a woman <IMAGE_REF_0> is walking. Use Image1 as the starting frame. Use Image2 as a reference for the video generation.
```

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

### CLI usage examples for inspect_video.py

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/inspect-video.md

CLI usage examples. Runs the script with default report, `--json` for JSON output, and `--raw` for raw ffprobe JSON.

```bash
./scripts/video/inspect_video.py media/output.mp4
./scripts/video/inspect_video.py media/output.mp4 --json
./scripts/video/inspect_video.py media/output.mp4 --raw
```

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

### Install skills with Context7 skills CLI

Source: https://github.com/google-gemini/gemini-skills/blob/main/README.md

Use the Context7 skills CLI to browse and install Gemini API skills. The first command lists available skills interactively; the second installs a specific skill by name.

```sh
# Interactively browse and install skills.
npx ctx7 skills install /google-gemini/gemini-skills

# Install a specific skill (e.g., gemini-api-dev).
npx ctx7 skills install /google-gemini/gemini-skills gemini-api-dev
```

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

### Install skills in OpenAI Codex

Source: https://github.com/google-gemini/gemini-skills/blob/main/README.md

Add the Gemini skills marketplace source and install the plugin in OpenAI Codex. The first command adds the marketplace; the second installs the plugin.

```sh
# Add the marketplace source
codex plugin marketplace add https://github.com/google-gemini/gemini-skills

# Install the plugin
codex plugin add gemini-skills@gemini-skills
```

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

### Install google-genai SDK

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Install or upgrade the google-genai Python SDK to version 2.19.0 or later, which is required for the interactions client and full video output resolution configuration.

```bash
pip install -U google-genai
```

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

### Install skills in Claude Code

Source: https://github.com/google-gemini/gemini-skills/blob/main/README.md

Register the Gemini skills marketplace and install the plugin in Claude Code. The first command adds the marketplace source; the second installs the plugin.

```sh
# Register the marketplace
/plugin marketplace add google-gemini/gemini-skills

# Install the plugin
/plugin install gemini-skills@gemini-skills
```

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

### Install skills in Cursor

Source: https://github.com/google-gemini/gemini-skills/blob/main/README.md

Install the Gemini skills directly from the Cursor plugin directory or via the editor command.

```text
/add-plugin google-gemini/gemini-skills
```

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

### Connect to Gemini Live API

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-live-api-dev/SKILL.md

Establish a live session with the Gemini Live API, configuring audio response modality and a system instruction. The Python example uses an async context manager; the JavaScript example sets up connection callbacks.

```python
from google.genai import types

config = types.LiveConnectConfig(
    response_modalities=[types.Modality.AUDIO],
    system_instruction=types.Content(
        parts=[types.Part(text="You are a helpful assistant.")]
    )
)

async with client.aio.live.connect(model="gemini-3.8-live", config=config) as session:
    pass  # Session is active
```

```javascript
const session = await ai.live.connect({
  model: 'gemini-3.8-live',
  config: {
    responseModalities: ['audio'],
    systemInstruction: { parts: [{ text: 'You are a helpful assistant.' }] }
  },
  callbacks: {
    onopen: () => console.log('Connected'),
    onmessage: (response) => console.log('Message:', response),
    onerror: (error) => console.error('Error:', error),
    onclose: () => console.log('Closed')
  }
});
```

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

### Install skills with Vercel skills CLI

Source: https://github.com/google-gemini/gemini-skills/blob/main/README.md

Use the Vercel skills CLI to browse and install Gemini API skills. The first command lists available skills interactively; the second installs a specific skill by name.

```sh
# Interactively browse and install skills.
npx skills add google-gemini/gemini-skills --list

# Install a specific skill (e.g., gemini-api-dev).
npx skills add google-gemini/gemini-skills --skill gemini-api-dev
```

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

### prep_video(input_path, output_path, start_time_str=None, duration=10, fps=None, resolution=None, strip_audio=False)

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Preps a video file by trimming, optionally re-encoding to target fps and resolution. It validates input, resolves start time, builds and runs an ffmpeg command, and returns the output video metadata.

```APIDOC
## prep_video(input_path, output_path, start_time_str=None, duration=10, fps=None, resolution=None, strip_audio=False)

### Description
Preps a video file by trimming, optionally re-encoding to target fps and resolution. It validates input, resolves start time, builds and runs an ffmpeg command, and returns the output video metadata.

### Parameters
- **input_path** (str) - Required - Source video path
- **output_path** (str) - Required - Destination; if falsy, defaults to `media/prepped_<basename>.mp4` (directory created)
- **start_time_str** (str) - Optional - Start timecode; `None` → interactive prompt (TTY only, source > 10 s) offering first 10 s (default) / last 10 s / custom timecode; non-TTY default `"0"`
- **duration** (int) - Optional - Trim length in seconds (default: 10)
- **fps** (int) - Optional - Target frame rate (`-r`); `None` keeps original
- **resolution** (str) - Optional - Target `WIDTHxHEIGHT` (e.g. `1280x720`), scale-to-fit preserving aspect ratio, dimensions rounded to even; `None` keeps original unless the file is > 25 MB
- **strip_audio** (bool) - Optional - Drop the audio stream (`-an`); also applied automatically when the source has no audio stream

### Behavior
1. Validates `input_path` exists; verifies `ffmpeg` availability.
2. Inspects source via `inspect_video(input_path)` for `duration_seconds`, `size_bytes`, `has_audio`, video width/height.
3. Resolves start time (interactive prompt when TTY + > 10 s); validates bounds (`start_seconds < 0` or `>= total_duration` → error).
4. Resolution logic: explicit `resolution` → scale-to-fit filter `scale=W:H` (aspect preserved, even dims); no explicit resolution but source > 25 MB → proportional downscale to max `1280x720` landscape / `720x1280` portrait with a printed recommendation.
5. Builds and runs ffmpeg:


ffmpeg -y -ss <start> -i <input> -t <duration> [-vf scale=W:H] -c:v libx264 -pix_fmt yuv420p [-r <fps>] [-an | -c:a aac -b:a 128k -ac 2] <output>


Video codec always `libx264`; pixel format always `yuv420p`; audio, when kept, is converted to AAC stereo 128 kbps.
6. Re-inspects the output and returns its metadata.

### Return
- **dict** - `inspect_video(output_path)` result (shape in [types.md](../types.md))

### Errors
- **FileNotFoundError** - `input_path` does not exist
- **RuntimeError** - `ffmpeg` not installed / not on `PATH`
- **ValueError** - timecode parsing failure (wraps `parse_timecode` errors)
- **ValueError** - start time out of bounds for the source length
- **ValueError** - `resolution` not `WIDTHxHEIGHT` (e.g. `1280x720`)
- **RuntimeError** - ffmpeg exited non-zero; full stderr echoed
```

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

### Raw WebSocket setup for live translation (gemini-3.5-live-translate-preview)

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-live-api-dev-skill.md

JSON setup message for the Gemini Live API to enable live translation to Spanish with echo. Place translationConfig inside generationConfig as shown.

```json
{
  "setup": {
    "model": "models/gemini-3.5-live-translate-preview",
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "translationConfig": {
        "targetLanguageCode": "es",
        "echoTargetLanguage": true
      }
    }
  }
}
```

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

### Install skills via AGY CLI

Source: https://github.com/google-gemini/gemini-skills/blob/main/README.md

Install the Gemini skills through the Antigravity AGY CLI. The skills are also bundled with Antigravity under ⚙️ → Customizations → Build with Google Plugins.

```sh
# Install it directly
agy plugin install https://github.com/google-gemini/gemini-skills
```

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

### Programmatic Usage Examples

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/inspect-video.md

Programmatic usage of the inspect_video module with examples for inspection and error handling.

```APIDOC
## Programmatic Usage

### Description
Use the `inspect_video` function and `format_size` helper programmatically.

### Example
```python
from inspect_video import inspect_video, format_size

info = inspect_video("media/output.mp4")
print(info["duration_seconds"])   # 10.0
print(info["video"]["resolution"])  # "1280x720"
print(info["has_audio"])          # True
print(format_size(info["size_bytes"]))  # "1.23 MB"
```

### Error Handling
```python
from inspect_video import inspect_video

try:
    info = inspect_video("missing.mp4")
except FileNotFoundError as e:
    print("File missing:", e)
except RuntimeError as e:
    print("ffprobe unavailable:", e)
```
```

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

### Example prompt with 6 reference images

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Shows a prompt using six image references (<IMAGE_REF_0> through <IMAGE_REF_5>) to describe a studio fashion sequence with time segments. Use this as a template for prompts that reference multiple images in a timed sequence.

```text
[0-3s] A studio fashion sequence. Starting with woman <IMAGE_REF_0>, she is holding <IMAGE_REF_1>
[3-6s] Then we see the man <IMAGE_REF_2> holding <IMAGE_REF_3>
[6-10s] And finally another woman <IMAGE_REF_4> who is holding <IMAGE_REF_5> while walking.
```

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

### Prompt with source and reference declarations (video and image references)

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Example prompt that declares a video reference and an image reference, then instructs the model to use Video1 as a character reference and Image1 as an object reference. Use this pattern for prompts that combine video and image references.

```text
[# References <IMAGE_REF_0>@Image1 <VIDEO_REF_0>@Video1] The woman in <VIDEO_REF_0> is playing the violin shown in <IMAGE_REF_0>. Use Video1 as a character reference and Image1 as an object reference.
```

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

### Streaming with Python

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-api-dev/SKILL.md

Python example demonstrating how to create a streaming interaction with the Gemini API, handling step.delta and interaction.completed events.

```APIDOC
## POST /interactions/create (streaming)

### Description
Creates a streaming interaction with the Gemini API, receiving server-sent events as the model generates a response.

### Method
POST

### Endpoint
/interactions/create

### Parameters
#### Request Body
- **model** (string) - Required - The model identifier to use, e.g., "gemini-3.8-flash".
- **input** (string) - Required - The user input prompt.
- **stream** (boolean) - Required - Set to true to enable streaming.

### Request Example
```json
{
  "model": "gemini-3.8-flash",
  "input": "Explain quantum entanglement in simple terms.",
  "stream": true
}
```

### Response
#### Success Response (200)
- **event_type** (string) - The type of event: "step.delta" or "interaction.completed".
- **delta** (object) - Present for step.delta events, contains the delta data.
  - **type** (string) - The type of delta, e.g., "text".
  - **text** (string) - The text content of the delta.
- **interaction** (object) - Present for interaction.completed events, contains usage information.
  - **usage** (object) - Usage details.
    - **total_tokens** (number) - Total token count.

#### Response Example
```json
{
  "event_type": "step.delta",
  "delta": {
    "type": "text",
    "text": "Quantum entanglement is..."
  }
}
```

```json
{
  "event_type": "interaction.completed",
  "interaction": {
    "usage": {
      "total_tokens": 123
    }
  }
}
```
```

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

### Python Quick Start: Create Interaction

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-api-dev/SKILL.md

Create a client and generate a response using the interactions API. The model is set to "gemini-3.8-flash" and the output is printed using the output_text property.

```python
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Tell me a short joke about programming."
)
print(interaction.output_text)
```

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

### Raw WebSocket setup for live transcription (gemini-3.5-transcribe-live)

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-live-api-dev-skill.md

JSON setup message for the Gemini Live API to enable live transcription with smart mode. Use this as the initial WebSocket message to configure the model and response modalities.

```json
{
  "setup": {
    "model": "models/gemini-3.5-transcribe-live",
    "generationConfig": {
      "responseModalities": ["TEXT"],
      "speechConfig": { "voiceConfig": {} }
    },
    "inputAudioTranscription": { "mode": "smart" }
  }
}
```

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

### prep_video() trim first 10 seconds with defaults

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Trims the first 10 seconds from a video using default options. The interactive prompt for start time only appears when the source is longer than 10 seconds and running in a TTY.

```python
from prep_video import prep_video

info = prep_video("path/to/source.mp4", output_path="media/trimmed.mp4")
# interactive TTY prompt only fires when source > 10s
print(info["video"]["resolution"])

```

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

### First frame to video generation

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Generate a video starting from a given first frame image using the --first-frame flag.

```bash
./scripts/video/generate_video.py "The waves crash against the shore." --first-frame start.png --output media/waves.mp4
```

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

### Looping video with identical start and end frame

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Create a looping video by providing the same image for both --first-frame and --last-frame.

```bash
./scripts/video/generate_video.py "A crystal orb spinning continuously in place" --first-frame orb.png --last-frame orb.png --output media/loop.mp4
```

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

### Prep video trimming last 10s

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Trims the last 10 seconds of the video automatically calculating the starting point based on source length. Use --start last to target the end of the file.

```bash
./scripts/video/prep_video.py path/to/source.mp4 --start last
```

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

### Parallel batch execution from JSON config (with example jobs.json)

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Executes fully configured, distinct generation and editing jobs in parallel using a JSON batch file. The command references jobs.json and sets concurrency to 3. The example JSON includes jobs for interpolation, extension with references, 4K generation, video-reference styling, and anime style editing with audio options.

```bash
./scripts/video/generate_video.py --batch jobs.json --concurrency 3
```

```json
[
  {
    "prompt": "A smooth timelapse from sunrise to sunset.",
    "first_frame": "start.png",
    "last_frame": "end.png",
    "resolution": "1080p",
    "output": "media/interpolation.mp4"
  },
  {
    "prompt": "Extend this video. The scene continues with the character in <IMAGE_REF_0> dancing like <VIDEO_REF_0>.",
    "extend": "media/sunset.mp4",
    "image": "character.png",
    "video_reference": "dance_ref.mp4",
    "output": "media/extended_with_refs.mp4"
  },
  {
    "prompt": "A macro shot of a crystal orb refracting cosmic nebula colors.",
    "resolution": "4k",
    "output": "media/nebula_orb_4k.mp4"
  },
  {
    "prompt": "A musician playing cello in the style of <VIDEO_REF_0>.",
    "video_reference": "cello_ref.mp4",
    "output": "media/cello.mp4"
  },
  {
    "prompt": "Transform the style to Japanese anime.",
    "video": "input.mp4",
    "output": "media/anime_style.mp4",
    "strip_audio": false,
    "aspect_ratio": "16:9"
  }
]
```

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

### prep_video() error handling try/except example

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Shows the error types that prep_video can raise: FileNotFoundError for a missing source, ValueError for invalid timecode/resolution/bounds, and RuntimeError for ffmpeg failures.

```python
from prep_video import prep_video

try:
    info = prep_video("missing.mp4", output_path="media/out.mp4")
except FileNotFoundError as e:
    print("Source missing:", e)
except ValueError as e:
    print("Bad timecode/resolution/bounds:", e)  # e.g. start beyond video length
except RuntimeError as e:
    print("ffmpeg issue:", e)

```

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

### Video-referenced video generation

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Generate a video using one or more reference videos to guide character, object, or motion style. Ideal reference video duration is ~3s, and up to 3 reference videos are recommended.

```bash
./scripts/video/generate_video.py "A musician playing cello in the style of <VIDEO_REF_0>" --video-reference ref_dance.mp4 --output media/cello.mp4
```

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

### LiveConnectConfig

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-live-api-dev-skill.md

Configuration type for live session setup, including response modalities, system instruction, tools, and transcription settings.

```APIDOC
## LiveConnectConfig

### Description
Configuration type for live session setup, including response modalities, system instruction, tools, and transcription settings.

### Fields
- **response_modalities** (array) - Optional - Response modalities (e.g., AUDIO, TEXT).
- **system_instruction** (object) - Optional - System instruction.
- **tools** (array) - Optional - Tool declarations.
- **thinking_config** (ThinkingConfig) - Optional - Thinking configuration.
- **translation_config** (TranslationConfig) - Optional - Translation configuration.
- **input_audio_transcription** (AudioTranscriptionConfig) - Optional - Input audio transcription settings.
- **output_audio_transcription** (AudioTranscriptionConfig) - Optional - Output audio transcription settings.

### Example
No explicit example provided.
```

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

### JavaScript/TypeScript Quick Start: Create Interaction

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-api-dev/SKILL.md

Create a client and generate a response using the interactions API in JavaScript/TypeScript. The model is set to "gemini-3.8-flash" and the output is logged to the console.

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

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: "gemini-3.8-flash",
    input: "Tell me a short joke about programming.",
});
console.log(interaction.output_text);
```

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

### Image-referenced video generation

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Generate a video using an image reference to guide the style or content. The prompt can reference the image using <IMAGE_REF_0>.

```bash
./scripts/video/generate_video.py "A cybernetic warrior in the style of <IMAGE_REF_0>" --image reference.png --output media/warrior.mp4
```

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

### Live API with extended thinking and non-blocking tool calls (Python and JavaScript)

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-live-api-dev/references/migration.md

Both examples configure the gemini-3.8-live-extended-thinking model with a NON_BLOCKING search_flights function declaration, low thinking level, and AUDIO response modality. They handle three message types: play audio from model turns, execute non-blocking tool calls by sending a FunctionResponse, and detect idle sessions via interaction_status/IDLE. The Python version uses async/await with client.aio.live.connect; the JavaScript version uses callbacks with ai.live.connect.

```python
import asyncio
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-3.8-live-extended-thinking"

search_flights = types.FunctionDeclaration(
    name="search_flights",
    description="Searches for available flights to a destination.",
    behavior="NON_BLOCKING",
    parameters={
        "type": "OBJECT",
        "properties": {"destination": {"type": "STRING"}},
        "required": ["destination"],
    },
)

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    thinking_config=types.ThinkingConfig(thinking_level="low"),
    tools=[types.Tool(function_declarations=[search_flights])],
)

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        async for message in session.receive():
            status = getattr(message, "interaction_status", None)

            # 1. Play spoken conversational fillers or final audio response
            if message.server_content and message.server_content.model_turn:
                for part in message.server_content.model_turn.parts:
                    if part.inline_data:
                        # Process 24kHz PCM audio chunk
                        pass

            # 2. Execute asynchronous non-blocking tool call
            if message.tool_call:
                for call in message.tool_call.function_calls:
                    response = types.FunctionResponse(
                        id=call.id,
                        name=call.name,
                        response={"result": "Flight DL 145 ($145)"},
                    )
                    await session.send_tool_response(function_responses=[response])

            # 3. Session is idle only when status == "IDLE"
            if status == "IDLE":
                print("Session is idle and ready for user input.")

if __name__ == "__main__":
    asyncio.run(main())
```

```javascript
import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});
const model = 'gemini-3.8-live-extended-thinking';

const searchFlights = {
  name: 'search_flights',
  description: 'Searches for available flights to a destination.',
  behavior: 'NON_BLOCKING',
  parameters: {
    type: 'OBJECT',
    properties: { destination: { type: 'STRING' } },
    required: ['destination'],
  },
};

const session = await ai.live.connect({
  model,
  config: {
    responseModalities: ['audio'],
    thinkingConfig: { thinkingLevel: 'low' },
    tools: [{ functionDeclarations: [searchFlights] }],
  },
  callbacks: {
    onmessage: async (message) => {
      // 1. Play spoken conversational fillers or final audio response
      if (message.serverContent?.modelTurn?.parts) {
        for (const part of message.serverContent.modelTurn.parts) {
          if (part.inlineData) {
            // Process base64 24kHz PCM audio chunk
          }
        }
      }

      // 2. Execute asynchronous non-blocking tool call
      if (message.toolCall?.functionCalls) {
        for (const call of message.toolCall.functionCalls) {
          session.sendToolResponse({
            functionResponses: [{
              id: call.id,
              name: call.name,
              response: { result: 'Flight DL 145 ($145)' },
            }],
          });
        }
      }

      // 3. Session is idle only when interactionStatus === 'IDLE'
      if (message.interactionStatus === 'IDLE') {
        console.log('Session is idle and waiting for input.');
      }
    },
  },
});
```

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

### Single scene video prompt

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Example prompt for generating a single-scene video. Include phrases like 'In a single unbroken scene' or 'No scene cuts' to avoid multiple shots.

```text
Continuous, unbroken handheld shot of a fluffy tabby cat sitting on a sunny windowsill, looking out into a leafy garden. The cat's tail twitches slowly, and its ears rotate slightly toward ambient noises. Sunbeams illuminate dust motes in the air. Sound design: Gentle breeze, distant bird chirps. No dialogue.
```

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

### Programmatic inspection with inspect_video

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/inspect-video.md

Programmatic inspection example. Calls `inspect_video` on a video file and prints fields from the returned dict, including duration, resolution, audio presence, and formatted file size.

```python
from inspect_video import inspect_video, format_size

info = inspect_video("media/output.mp4")
print(info["duration_seconds"])   # 10.0
print(info["video"]["resolution"])  # "1280x720"
print(info["has_audio"])          # True
print(format_size(info["size_bytes"]))  # "1.23 MB"
```

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

### Prep video trimming first 10s (default or explicit)

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Normalizes, trims, and formats a video file to fit Gemini Omni Flash limits. The default trims the first 10 seconds; use --start and --duration to specify an explicit timecode-based trim.

```bash
./scripts/video/prep_video.py path/to/source.mp4
```

```bash
./scripts/video/prep_video.py path/to/source.mp4 --start 0 --duration 10
```

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

### main() (CLI entry point)

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/inspect-video.md

Command-line interface for inspecting video files with options for JSON and raw output.

```APIDOC
## CLI: `inspect_video.py`

### Description
Command-line interface for inspecting video files. Prints a summary report, JSON output, or raw ffprobe output.

### Usage
```
usage: inspect_video.py [-h] [--json] [--raw] file
```

### Arguments
- `file` (positional) - Required - Path to the video file to inspect
- `--json` (flag) - Optional - Print the parsed summary dict as JSON
- `--raw` (flag) - Optional - Print the complete unmodified ffprobe JSON

### Precedence
`--raw` beats `--json`; otherwise `--json` prints `json.dumps(info, indent=2)`, else `print_terminal_report(info)`.

### Exit Codes
- `0` - Inspection succeeded (report or JSON printed)
- `1` - Any exception → `Error inspecting video: <e>` on stderr
```

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

### prep_video.py CLI usage text

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Command-line usage string for prep_video.py when run with --help. Shows the accepted flags and positional file argument.

```text
usage: prep_video.py [-h] [--start START] [--duration DURATION] [--fps FPS]
                     [--resolution RESOLUTION] [--output OUTPUT] [--strip-audio] file

```

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

### CLI: prep_video.py

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Command-line interface for preparing a video for Gemini, with flags for trimming, encoding, and audio stripping.

```APIDOC
## CLI: `prep_video.py`

### Description
Command-line interface for preparing a video for Gemini. Accepts a source video file and optional flags to control trimming, frame rate, resolution, output path, and audio stripping.

### Usage
```
usage: prep_video.py [-h] [--start START] [--duration DURATION] [--fps FPS]
                     [--resolution RESOLUTION] [--output OUTPUT] [--strip-audio] file
```

### Arguments
- **file** (positional) - Required - Path to the source video.
- `--start` / `-s` (str) - Optional - Start time as `seconds`, `MM:SS`, `HH:MM:SS`, or `last` (last 10 s). Default: `0`; prompted when TTY and video > 10 s.
- `--duration` / `-d` (int) - Optional - Trim segment length in seconds. Default: `10`.
- `--fps` / `-r` (int) - Optional - Target frame rate; `None` = original.
- `--resolution` / `-g` (str) - Optional - Target resolution e.g. `1280x720`; automatic downscale when source > 25 MB.
- `--output` / `-o` (str) - Optional - Output path. Default: `media/prepped_<name>.mp4`.
- `--strip-audio` / `-a` (flag) - Optional - Strip/disable audio so the model generates new audio. Default: `False`.

### Exit Codes
- **0** - Success; prints `Prepped Video Specifications:` report (file size, duration, bitrate, resolution, fps, video codec, optional audio spec).
- **1** - Any exception → `Error prepping video: <e>` on stderr.

### Examples
```bash
./scripts/video/prep_video.py path/to/source.mp4
./scripts/video/prep_video.py path/to/source.mp4 --start 00:03 --output media/custom.mp4
./scripts/video/prep_video.py path/to/source.mp4 --start last --fps 30 --resolution 1920x1080
./scripts/video/prep_video.py path/to/source.mp4 --strip-audio
```
```

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

### Prep video trimming from specific timecode

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Trims 10 seconds starting at a specific timecode (MM:SS or HH:MM:SS) using --start. The output file is specified with --output.

```bash
./scripts/video/prep_video.py path/to/source.mp4 --start 00:03 --output media/custom.mp4
```

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

### Generate video with image and video references

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Generates an extended video by passing both reference images and reference videos simultaneously. Use --extend to specify the source video, --image for the image reference, --video-reference for the video reference, and --output for the destination file.

```bash
./scripts/video/generate_video.py "Extend this video. The character in <IMAGE_REF_0> enters dancing like the dancer in <VIDEO_REF_0>." --extend media/sunset.mp4 --image character.png --video-reference dance_ref.mp4 --output media/sunset_extended_with_refs.mp4
```

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

### Connect to Gemini Live API and send realtime inputs

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-live-api-dev-skill.md

Establishes a live session with the gemini-3.8-live model, configures audio-only responses with a system instruction, and registers callbacks for open, message, error, and close events. After connecting, it sends realtime inputs (text, audio, video, and audio stream end for hybrid VAD) and tool responses. The message callback receives response objects with fields like response.serverContent?.modelTurn?.parts[].inlineData.data (base64 audio) and response.serverContent?.interimInputTranscription?.text.

```javascript
const session = await ai.live.connect({
  model: 'gemini-3.8-live',
  config: {
    responseModalities: ['audio'],
    systemInstruction: { parts: [{ text: 'You are a helpful assistant.' }] }
  },
  callbacks: {
    onopen: () => console.log('Connected'),
    onmessage: (response) => console.log('Message:', response),
    onerror: (error) => console.error('Error:', error),
    onclose: () => console.log('Closed')
  }
});

session.sendRealtimeInput({ text: 'Hello, how are you?' });
session.sendRealtimeInput({ audio: { data: chunk.toString('base64'), mimeType: 'audio/pcm;rate=16000' } });
session.sendRealtimeInput({ video: { data: frame.toString('base64'), mimeType: 'image/jpeg' } });
session.sendRealtimeInput({ audioStreamEnd: true }); // Hybrid VAD
session.sendToolResponse({ functionResponses: [{ id, name, response }] });
```

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

### client.agents.*

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-api-dev-skill.md

Provides CRUD operations for managing agents: create, list, get, and delete.

```APIDOC
## client.agents.create(...)

### Description
Creates a new agent with a specified base agent, system instruction, and base environment.

### Method
SDK method call

### Endpoint
`client.agents.create(...)`

### Parameters
- **id** (string) - Required - The agent ID.
- **base_agent** (string) - Required - The base agent identifier, e.g., `antigravity-preview-09-2026`.
- **system_instruction** (string) - Optional - The system instruction for the agent.
- **base_environment** (object) - Optional - The base environment configuration, e.g., `{"type": "remote", "sources": [{"type": "repository", "source": "...", "target": "/workspace/repo"}]}`.

### Request Example
```python
client.agents.create(
    id=...,
    base_agent="antigravity-preview-09-2026",
    system_instruction=...,
    base_environment={"type": "remote", "sources": [{"type": "repository", "source": "...", "target": "/workspace/repo"}]}
)
```

### Response
Returns the created agent object.

---

## client.agents.list()

### Description
Lists all agents.

### Method
SDK method call

### Endpoint
`client.agents.list()`

### Parameters
None.

### Request Example
```python
client.agents.list()
```

### Response
Returns a list of agent objects.

---

## client.agents.get(id)

### Description
Retrieves an agent by its ID.

### Method
SDK method call

### Endpoint
`client.agents.get(id)`

### Parameters
- **id** (string) - Required - The agent ID.

### Request Example
```python
client.agents.get(id=...)
```

### Response
Returns the agent object.

---

## client.agents.delete(id)

### Description
Deletes an agent by its ID.

### Method
SDK method call

### Endpoint
`client.agents.delete(id)`

### Parameters
- **id** (string) - Required - The agent ID.

### Request Example
```python
client.agents.delete(id=...)
```

### Response
Returns a confirmation or empty response.
```

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

### CLI usage for upload_file.py

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/upload-file.md

Shows how to invoke the upload script from the command line. The first command uploads an image with default settings. The second uploads a video with --no-wait and a custom name.

```bash
./scripts/upload_file.py path/to/image.png
./scripts/upload_file.py path/to/video.mp4 --no-wait --name "My Video"
```

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

### Error handling with inspect_video

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/inspect-video.md

Error handling example. Catches `FileNotFoundError` for missing files and `RuntimeError` for ffprobe unavailability.

```python
from inspect_video import inspect_video

try:
    info = inspect_video("missing.mp4")
except FileNotFoundError as e:
    print("File missing:", e)
except RuntimeError as e:
    print("ffprobe unavailable:", e)
```

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

### main() CLI

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/generate-video.md

Command-line interface for generate_video.py. Supports single generation, batch mode, and prompts file mode with various options.

```APIDOC
## `main()` (CLI entry point)

### Description
Executed when run as a script. Provides a command-line interface for generating videos.

### Usage
```
usage: generate_video.py [prompt] [options]
```

### Parameters
#### Positional Arguments
- **prompt** (str) - Optional - Single-generation prompt

#### Options
- `--first-frame` / `-f` (str) - Default: `None` - Starting frame image
- `--last-frame` / `-l` (str) - Default: `None` - Final frame image (requires `--first-frame`; validated at parse time via `parser.error`)
- `--image`, `--image-reference`, `--ref-image` / `-i` (append) - Default: `[]` - Reference image(s), repeatable
- `--video` / `-v` (append) - Default: `[]` - Source video(s) for editing, repeatable
- `--extend` / `-e` (str) - Default: `None` - Video to extend
- `--video-reference`, `--ref-video` / `-vr` (append) - Default: `[]` - Reference video(s), repeatable
- `--task` (choice: `text_to_video` | `image_to_video` | `reference_to_video` | `edit` | `extend`) - Default: `None` - Explicit task mode
- `--aspect-ratio` (choice: `16:9` | `9:16`) - Default: `"16:9"` - Aspect ratio
- `--duration` (argparse_duration_type) - Default: `None` - Integer 3–10 s (e.g. `5`, `10`)
- `--resolution` / `-res` (argparse_resolution_type) - Default: `None` - `360p`, `720p`, `1080p`, `4k`
- `--model` (str) - Default: `gemini-omni-1.1-flash` - Model ID
- `--output` / `-o` (str) - Default: `media/output.mp4` - Output path (single mode)
- `--strip-audio` / `-a` (flag) - Default: `False` - Strip audio before upload
- `--previous-interaction-id` (str) - Default: `None` - Turn-by-turn edit/extend
- `--timeout` (int) - Default: `600` - Per-request timeout (s); `900+` recommended for 4K multi-turn
- `--batch` (str) - Default: `None` - Path to JSON array of job dicts (schema in [types.md](../types.md))
- `--prompts-file` (str) - Default: `None` - Text file, one prompt per line; `#`-prefixed lines skipped; inherits the CLI's other flags
- `--concurrency` (int) - Default: `3` - Max `ThreadPoolExecutor` workers

### Execution Modes
1. `--batch` wins; must be a JSON **list** of job objects, else exit 1.
2. Else `--prompts-file` — builds jobs from lines with the current CLI flags.
3. Else single `prompt` (required, else usage help + exit 1).

### Exit Codes
| Code | Condition |
|------|-----------|
| `0` | Single generation succeeded; or batch run with `failed_count == 0` |
| `1` | `GEMINI_API_KEY` unset; prompt missing; batch/prompts file missing or invalid; single-generation exception; or batch run with `failed_count > 0` |
| `2` | argparse usage error (sanitized) |

Batch mode prints a summary: `Total: N | Success: N | Failed: N | Skipped: N` with per-job lines.
```

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

### First and last frame transition

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Generate a smooth transition between a starting frame and an ending frame. The --last-frame flag must be used together with --first-frame.

```bash
./scripts/video/generate_video.py "A smooth timelapse from sunrise to sunset" --first-frame start.png --last-frame end.png --output media/interpolation.mp4
```

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

### ai.live.connect

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-live-api-dev-skill.md

Establishes a live session with the Gemini model, accepting configuration and callbacks for connection events.

```APIDOC
## ai.live.connect

### Description
Establishes a live session with the Gemini model, accepting configuration and callbacks for connection events.

### Method
connect

### Endpoint
ai.live.connect

### Parameters
#### Request Body
- **model** (string) - Required - The model identifier, e.g., 'gemini-3.8-live'.
- **config** (LiveConnectConfig) - Required - Configuration object for the session.
  - **responseModalities** (array) - Optional - Response modalities, e.g., ['audio'].
  - **systemInstruction** (object) - Optional - System instruction with parts array containing text.
- **callbacks** (object) - Required - Event callbacks.
  - **onopen** (function) - Optional - Called when connection opens.
  - **onmessage** (function) - Optional - Called when a message is received.
  - **onerror** (function) - Optional - Called on error.
  - **onclose** (function) - Optional - Called when connection closes.

### Request Example
```js
const session = await ai.live.connect({
  model: 'gemini-3.8-live',
  config: {
    responseModalities: ['audio'],
    systemInstruction: { parts: [{ text: 'You are a helpful assistant.' }] }
  },
  callbacks: {
    onopen: () => console.log('Connected'),
    onmessage: (response) => console.log('Message:', response),
    onerror: (error) => console.error('Error:', error),
    onclose: () => console.log('Closed')
  }
});
```

### Response
#### Success Response
- **session** (LiveSession) - The live session object with methods for sending input and tool responses.

#### Response Example
```js
const session = await ai.live.connect({ ... });
```
```

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

### Inspect video with JSON summary

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Gets a pre-parsed, structured JSON summary of the video inspection. The --json flag outputs parsed metadata in JSON format.

```bash
./scripts/video/inspect_video.py media/output.mp4 --json
```

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

### Building video_config for generate_video

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/generate-video.md

Shows how the video_config dictionary is constructed, including the aspect_ratio, duration, and resolution fields. Note that aspect_ratio is omitted when task == "extend".

```python
video_config = {
    "type": "video",
    "delivery": "uri"
}
# aspect_ratio omitted when task == "extend"
video_config["aspect_ratio"] = aspect_ratio
video_config["duration"] = duration
video_config["resolution"] = parse_and_validate_resolution(resolution)
```

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

### ffmpeg command template

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

The ffmpeg command built and run by prep_video. Uses libx264, yuv420p, and optional scaling, fps, and audio handling.

```bash
ffmpeg -y -ss <start> -i <input> -t <duration> [-vf scale=W:H] -c:v libx264 -pix_fmt yuv420p [-r <fps>] [-an | -c:a aac -b:a 128k -ac 2] <output>
```

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

### parse_timecode(time_str, total_duration=None)

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/prep-video.md

Parses a time string (seconds, MM:SS, HH:MM:SS, or 'last') into float seconds. Used to resolve start times for video trimming.

```APIDOC
## parse_timecode(time_str, total_duration=None)

### Description
Parses a time string (seconds, MM:SS, HH:MM:SS, or 'last') into float seconds.

### Parameters
- **time_str** (str | None) - Required - `"last"`, `"MM:SS"`, `"HH:MM:SS"`, or float seconds (string)
- **total_duration** (float | None) - Optional - Source duration; required to resolve `"last"`

### Return
- **float** - seconds:
  - `None`/empty → `0.0`
  - `"last"` → `0.0` if `total_duration <= 10.0`, else `total_duration - 10.0`
  - `"MM:SS"` → `m * 60.0 + s`; `"HH:MM:SS"` → `h * 3600.0 + m * 60.0 + s`
  - numeric → `float(time_str)`

### Errors
- **ValueError** - `"last"` without `total_duration`
- **ValueError** - timecode with more than 3 colon-separated parts
- **ValueError** - unparseable string
```

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

### Connect to Gemini Live session (Python)

Source: https://github.com/google-gemini/gemini-skills/blob/main/_autodocs/api-reference/gemini-live-api-dev-skill.md

Establishes a live session with the Gemini 3.8 model using the Python SDK. Requires google-genai >= 2.3.0. The config sets audio-only response modality and a system instruction.

```python
from google.genai import types

config = types.LiveConnectConfig(
    response_modalities=[types.Modality.AUDIO],
    system_instruction=types.Content(parts=[types.Part(text="You are a helpful assistant.")]),
)

async with client.aio.live.connect(model="gemini-3.8-live", config=config) as session:
    pass  # Session is active
```

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

### Pre-process video with prep_video.py

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Pre-processes a source video by setting the frame rate to 30 fps and resolution to 1920x1080. Use this before generating a video with Gemini Omni Flash.

```bash
./scripts/video/prep_video.py path/to/source.mp4 --fps 30 --resolution 1920x1080
```

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

### Inspect video with raw ffprobe JSON

Source: https://github.com/google-gemini/gemini-skills/blob/main/skills/gemini-omni-flash-api/SKILL.md

Gets the complete, unmodified ffprobe raw JSON dump. Use --raw to bypass parsing and see the full underlying ffprobe output.

```bash
./scripts/video/inspect_video.py media/output.mp4 --raw
```
Tokens:
Raw