Skip to content

Gemini API

Gemini Minions inherit google.adk.Agent, create isolated in-memory sessions, and return native ADK events.

gemini

Assembly: minions Filename: gemini.py Author: Terry D. Eppler Created: 09-05-2026

Last Modified By: Terry D. Eppler Last Modified On: 09-06-2026

 gemini.py
 Copyright © 2026 Terry D. Eppler

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

You can contact me at: terryeppler@gmail.com or eppler.terry@epa.gov

Google Agent Development Kit Minion implementations.

Minion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Agent

Provider-native Gemini workflow agent.

Initialize a Gemini Minion.

Parameters:

Name Type Description Default
model str

Gemini model identifier.

 required
instructions str

System instructions for the agent.

 required
tools Sequence[GeminiTool] | None

Optional Google ADK tools.

 None
max_turns int

Maximum model calls per execution.

 10
name str | None

Optional name overriding the implementation default.

 None

Returns:

Name Type Description
None None

Configuration is stored on the provider-native agent.
Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

normalize_name(name: str) -> str staticmethod

Create a valid Google ADK agent identifier.

Parameters:

Name Type Description Default
name str

Human-readable agent name.

 required

Returns:

Name Type Description
str str

Normalized ADK identifier.
Source code in gemini.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
@staticmethod
def normalize_name( name: str ) -> str:
    """Create a valid Google ADK agent identifier.

    Args:
        name (str): Human-readable agent name.

    Returns:
        str: Normalized ADK identifier.
    """
    value = re.sub( r'[^A-Za-z0-9_]+', '_', name.strip( ) ).strip( '_' ).lower( )
    throw_if( 'name', value )
    return f'agent_{value}' if value[ 0 ].isdigit( ) else value

create_runner() -> Runner

Create an isolated provider runner.

Returns:

Name Type Description
Runner Runner

Google ADK runner with automatic session creation.
Source code in gemini.py 
117
118
119
120
121
122
123
124
125
126
127
128
def create_runner( self ) -> Runner:
    """Create an isolated provider runner.

    Returns:
        Runner: Google ADK runner with automatic session creation.
    """
    return Runner(
        agent=self,
        app_name=f'minions_{self.name}',
        session_service=InMemorySessionService( ),
        auto_create_session=True,
    )

create_content(prompt: str) -> types.Content

Create provider-native user content.

Parameters:

Name Type Description Default
prompt str

User input for the workflow.

 required

Returns:

Type Description
Content

types.Content: Google Gen AI content object.
Source code in gemini.py 
131
132
133
134
135
136
137
138
139
140
141
def create_content( self, prompt: str ) -> types.Content:
    """Create provider-native user content.

    Args:
        prompt (str): User input for the workflow.

    Returns:
        types.Content: Google Gen AI content object.
    """
    throw_if( 'prompt', prompt )
    return types.Content( role='user', parts=[ types.Part.from_text( text=prompt ) ] )

select_result(events: Sequence[Event]) -> Event

Select the final event from an invocation.

Parameters:

Name Type Description Default
events Sequence[Event]

Events emitted by Google ADK.

 required

Returns:

Name Type Description
Event Event

Final-response event or the last emitted event.
Source code in gemini.py 
144
145
146
147
148
149
150
151
152
153
154
155
def select_result( self, events: Sequence[ Event ] ) -> Event:
    """Select the final event from an invocation.

    Args:
        events (Sequence[Event]): Events emitted by Google ADK.

    Returns:
        Event: Final-response event or the last emitted event.
    """
    throw_if( 'events', events )
    final_events = [ event for event in events if event.is_final_response( ) ]
    return final_events[ -1 ] if final_events else events[ -1 ]

run(prompt: str) -> Event

Execute the complete Gemini workflow synchronously.

Parameters:

Name Type Description Default
prompt str

User input for the workflow.

 required

Returns:

Name Type Description
Event Event

Final provider-native event.
Source code in gemini.py 
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
def run( self, prompt: str ) -> Event:
    """Execute the complete Gemini workflow synchronously.

    Args:
        prompt (str): User input for the workflow.

    Returns:
        Event: Final provider-native event.
    """
    throw_if( 'prompt', prompt )
    self.prompt = prompt
    runner = self.create_runner( )
    self.events = list( runner.run( user_id=self.name, session_id=uuid4( ).hex,
        new_message=self.create_content( prompt ),
        run_config=RunConfig( max_llm_calls=self.max_turns ), ) )
    self.result = self.select_result( self.events )
    return self.result

run_async(prompt: str) -> Event async

Execute the complete Gemini workflow asynchronously.

Parameters:

Name Type Description Default
prompt str

User input for the workflow.

 required

Returns:

Name Type Description
Event Event

Final provider-native event.
Source code in gemini.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
async def run_async( self, prompt: str ) -> Event:
    """Execute the complete Gemini workflow asynchronously.

    Args:
        prompt (str): User input for the workflow.

    Returns:
        Event: Final provider-native event.
    """
    throw_if( 'prompt', prompt )
    self.prompt = prompt
    runner = self.create_runner( )
    self.events = [ event async for event in
                    runner.run_async( user_id=self.name, session_id=uuid4( ).hex,
                        new_message=self.create_content( prompt ),
                        run_config=RunConfig( max_llm_calls=self.max_turns ), ) ]
    self.result = self.select_result( self.events )
    return self.result

stream(prompt: str) -> AsyncIterator[Event] async

Stream a complete Gemini workflow with automatic tool handling.

Parameters:

Name Type Description Default
prompt str

User input for the workflow.

 required

Yields:

Name Type Description
Event AsyncIterator[Event]

Provider-native streamed ADK event.
Source code in gemini.py 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
async def stream( self, prompt: str ) -> AsyncIterator[ Event ]:
    """Stream a complete Gemini workflow with automatic tool handling.

    Args:
        prompt (str): User input for the workflow.

    Yields:
        Event: Provider-native streamed ADK event.
    """
    throw_if( 'prompt', prompt )
    self.prompt = prompt
    self.events = [ ]
    runner = self.create_runner( )
    async for event in runner.run_async( user_id=self.name, session_id=uuid4( ).hex,
            new_message=self.create_content( prompt ),
            run_config=RunConfig( max_llm_calls=self.max_turns,
                streaming_mode=StreamingMode.SSE, ) ):
        self.events.append( event )
        if event.is_final_response( ):
            self.result = event
        yield event
    if self.events and self.result is None:
        self.result = self.events[ -1 ]

DataMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for data workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

GovernanceMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for governance workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

ResearchMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for research workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

CodingMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for software workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

WritingMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for writing workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

PlanningMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for planning workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

ComplianceMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for compliance, legal, and budget workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

BusinessMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for business, finance, and marketing workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

ImageGenerationMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for image-generation workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

ImageAnalysisMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for image-analysis workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

ImageEditingMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for image-editing workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

TranslationMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for translation workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

TranscriptionMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for transcription workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )

SpeechMinion(model: str, instructions: str, tools: Sequence[GeminiTool] | None = None, max_turns: int = 10, name: str | None = None)

Bases: Minion

Gemini Minion specialized for speech workflows.

Source code in gemini.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def __init__( self, model: str, instructions: str,
        tools: Sequence[ GeminiTool ] | None=None, max_turns: int=10,
        name: str | None=None ) -> None:
    """Initialize a Gemini Minion.

    Args:
        model (str): Gemini model identifier.
        instructions (str): System instructions for the agent.
        tools (Sequence[GeminiTool] | None): Optional Google ADK tools.
        max_turns (int): Maximum model calls per execution.
        name (str | None): Optional name overriding the implementation default.

    Returns:
        None: Configuration is stored on the provider-native agent.
    """
    throw_if( 'model', model )
    throw_if( 'instructions', instructions )
    if max_turns < 1:
        raise ValueError( 'Argument "max_turns" must be at least 1!' )
    default_name = type( self ).model_fields[ 'minion_name' ].default
    display_name = name or str( default_name )
    throw_if( 'name', display_name )
    provider_name = self.normalize_name( display_name )
    super( ).__init__( name=provider_name, display_name=display_name, model=model,
        instruction=instructions, tools=list( tools or [ ] ), max_turns=max_turns, )