Core

The main aspects of content generation with Gemini (like streaming, generation parameters, input manipulation etc.)

Setup

from gaspare.utils import *

import errno
import os

import mimetypes
import inspect

from urllib.parse import urlparse, parse_qs
from functools import wraps
from time import sleep

from google import genai
from google.genai import types

import PIL

from fastcore import imghdr
from fastcore.all import *
from fastcore.docments import *

from toolslm.funccall import call_func

c = genai.client.Client(api_key=os.environ.get("GEMINI_API_KEY"))

r = c.models.generate_content(model='gemini-2.0-flash', contents="Hi Gemini!")
mr = c.models.generate_images(
    model = 'imagen-3.0-generate-002',
    prompt = "Turtles in space",
    config = {"number_of_images": 2}
)
mmr = c.models.generate_content(model='gemini-2.0-flash-exp', 
                                contents="Generate a watercolor picture of a peaceful pond and write a Haiku about it",
                               config={"response_modalities": ["TEXT", "IMAGE"]})
r

Hi there! How can I help you today?

• usage_metadata: Cached: 0; In: 3; Out: 11; Total: 14
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.017145561901005833
  • content:
    • role: model
    • parts:
      parts[0]

      • text: Hi there! How can I help you today?
  • finish_reason: FinishReason.STOP

Creating messages

Messages sent to Gemini are made of a list of Parts, which can be text, or multimedia parts. Some multimedia files can be inlined as bytes (in particular images), but others need to be uploaded using the file API first. Although this is quite flexible, it’s a bit clunky, so we want to make it easier.

---

source

is_youtube_url

 is_youtube_url (url:str)

Check if the given URL is a valid YouTube video URL using urllib for parsing.

def is_youtube_url(url: str) -> bool:
    """Check if the given URL is a valid YouTube video URL using urllib for parsing."""
    parsed = urlparse(url)
    if parsed.scheme not in ('http', 'https'): return False
    host = parsed.netloc.lower()
    
    # Standard YouTube URL (e.g., https://www.youtube.com/watch?v=VIDEO_ID)
    if host in ('www.youtube.com', 'youtube.com', 'm.youtube.com'):
        if parsed.path == '/watch':
            query_params = parse_qs(parsed.query)
            if 'v' in query_params:
                video_id = query_params['v'][0]
                return len(video_id) == 11
            return False
        # Embedded YouTube URL (e.g., https://www.youtube.com/embed/VIDEO_ID)
        elif parsed.path.startswith('/embed/'):
            video_id = parsed.path.split('/embed/')[1]
            return len(video_id) == 11

    # Shortened YouTube URL (e.g., https://youtu.be/VIDEO_ID)
    elif host == 'youtu.be':
        video_id = parsed.path.lstrip('/')
        return len(video_id) == 11
    return False

A nice quality of life improvement recently introduced is the ability of handling youtube link directly. This makes using the unique video understanding capabilities way more practical.

---

source

mk_part

 mk_part (inp:Union[str,pathlib.Path,google.genai.types.Part,google.genai.
          types.File,PIL.Image.Image],
          c:google.genai.client.Client|None=None)

Turns an input fragment into a multimedia Part to be sent to a Gemini model

def mk_part(inp: Union[str, Path, types.Part, types.File, PIL.Image.Image], c: genai.Client|None=None):
    "Turns an input fragment into a multimedia `Part` to be sent to a Gemini model"
    api_client = c or genai.Client(api_key=os.environ["GEMINI_API_KEY"])
    if isinstance(inp, types.Part): return inp
    if isinstance(inp, types.File):
        if inp.state == 'PROCESSING':
            sleep(.2)
            return mk_part(api_client.files.get(name=inp.name))
        return types.Part(file_data={"file_uri": inp.uri, "mime_type": inp.mime_type})
    if isinstance(inp, PIL.Image.Image): return types.Part.from_bytes(data=inp.tobytes(), mime_type=inp.get_format_mimetype())
    if isinstance(inp, bytes):
        mt = mimetypes.types_map["." + imghdr.what(None, h=inp)]
        return types.Part.from_bytes(data=inp, mime_type=mt)
    p_inp = Path(inp)
    try:
        if p_inp.exists():
            mt = mimetypes.guess_type(p_inp)[0]
            if mt.split("/")[0] == "image": return types.Part.from_bytes(data=p_inp.read_bytes(), mime_type=mt)
            file = api_client.files.upload(file=p_inp)
            return mk_part(file, c)
    except OSError as e:
        if e.errno == errno.ENAMETOOLONG: pass ## File name too long. Not a path.
        else: raise e
    if is_youtube_url(inp): return types.Part.from_uri(file_uri=inp, mime_type='video/*')
    return types.Part.from_text(text=inp)

Notice that we cannot make mk_part a completely standalone function. Having access to the files API requires an a client. We could pass the genai.Client we have created before (or monkey patch mk_part into a class that has access to a client already), but for testing we create a new client each time.

pimg = mk_part(Path("../examples/match.png"))
mk_part(pimg)

• inline_data:
  • data: b’89PNG1a…’
  • mime_type: image/png

# This will take a bit of time, since the pdf needs to be uploaded
f = mk_part(Path("../examples/DeepSeek_R1.pdf"))
f

• file_data:
  • file_uri: https://generativelanguage.googleapis.com/v1beta/files/8q311nybbae1
  • mime_type: application/pdf

# This should be instant as we have just uploaded it
mk_part(f)

• file_data:
  • file_uri: https://generativelanguage.googleapis.com/v1beta/files/8q311nybbae1
  • mime_type: application/pdf

TODO: Notice that we are not handling the case when the file is expired, but these should not be long term objects anyways.

pilimg = types.Image(image_bytes = pimg.inline_data.data, mime_type=pimg.inline_data.mime_type)._pil_image
type(pilimg)

PIL.PngImagePlugin.PngImageFile

mk_part(pilimg)

• inline_data:
  • data: b’IG=52/>=8Z…’
  • mime_type: image/png

mk_part("https://youtu.be/r94MqbROsk0?si=TOppM8zHTJAK7lNn")

• file_data:
  • file_uri: https://youtu.be/r94MqbROsk0?si=TOppM8zHTJAK7lNn
  • mime_type: video/*

---

source

mk_parts

 mk_parts (inps, c=None)

def mk_parts(inps, c=None):
    return list(L(inps).map(mk_part, c=c)) if inps else [""]

try: a = c.models.generate_content(model="gemini-2.0-flash", contents=[])
except ValueError: b = c.models.generate_content(model="gemini-2.0-flash", contents=mk_parts([]))
b

Please provide me with more context! I need to know what you’d like me to do. For example, are you asking me to:

* Analyze some text you’ll provide? (e.g., “Analyze this passage for tone and theme…”)
* Write something for you? (e.g., “Write a poem about a cat…”)
* Answer a question? (e.g., “What is the capital of France?”)
* Summarize something? (e.g., “Summarize the plot of Hamlet…”)

I’m ready to help, but I need some instructions!

• usage_metadata: Cached: 0; In: 1; Out: 134; Total: 135
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.27737685815611884
  • content:
    • role: model
    • parts:
      parts[0]

      • text: Please provide me with more context! I need to know what you’d like me to do. For example, are you asking me to:

        • Analyze some text you’ll provide? (e.g., “Analyze this passage for tone and theme…”)
        • Write something for you? (e.g., “Write a poem about a cat…”)
        • Answer a question? (e.g., “What is the capital of France?”)
        • Summarize something? (e.g., “Summarize the plot of Hamlet…”)
        I’m ready to help, but I need some instructions!
  • finish_reason: FinishReason.STOP

parts = mk_parts(["../examples/DeepSeek_R1.pdf", "In one sentence, what is this?"], c=c)

c.models.generate_content(model="gemini-2.0-flash", contents=parts)

This is a research paper introducing DeepSeek-R1, a language model that enhances reasoning capabilities through reinforcement learning, achieving performance comparable to OpenAI-01-1217, and includes the release of open-source models.

• usage_metadata: Cached: 0; In: 5684; Out: 49; Total: 5733
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.27534636672662227
  • content:
    • role: model
    • parts:
      parts[0]

      • text: This is a research paper introducing DeepSeek-R1, a language model that enhances reasoning capabilities through reinforcement learning, achieving performance comparable to OpenAI-01-1217, and includes the release of open-source models.
  • finish_reason: FinishReason.STOP

Handling multiturn conversations

In order to generate content, the API expects as input a list of Content objects, each being a potentially multi Part message. A lot of stuff happens under the hood to automatically convert various kind of inputs into a list of Content, but there is an ambiguous case that we have to resolve: if our input is a list of strings, should it treat it as a multiturn conversation or should it be treated as a single user message with several text parts? We will adopt the following conventions:

A potential Content message is one of the following:

• A Content or ContentDict object
• A dictionary (with role and contents keys)
• A list

The input to the client will be treated as a multiturn conversation only if it is a list and one of its items is a potential Content message, otehrwise the input will be treated as a single message.

---

source

mk_contents

 mk_contents (inps, cli=None)

def mk_content(content, role='user', cli=None):
    if isinstance(content, types.Content): return content.model_copy(update={'role': content.role or role})
    if isinstance(content, dict): mk_content(types.Content.model_construct(types.ContentDict(**content)), role)
    c = cli or genai.Client(api_key=os.environ['GEMINI_API_KEY'])
    return types.Content(role=role, parts=mk_parts(content, c=c))

def _is_msg(item):
    if isinstance(item, (types.Content, list)): return True
    if isinstance(item, dict):
        try:
            types.ContentDict(**item)
            return True
        except: return False

def mk_contents(inps, cli=None):
    if not (is_listy(inps) and any(_is_msg(o) for o in inps)): return [mk_content(inps, cli=cli)]
    return [mk_content(o, ('user', 'model')[i % 2], cli) for i, o in enumerate(inps)]

---

source

mk_content

 mk_content (content, role='user', cli=None)

ex1 = ["Hi I am Miko", "Hi Miko, how are you?", "What is my name again?"]
ex2 = ["What is this video about?", "https://youtu.be/_5SpM-QcccU?si=eEpleCQLAqDWGron"]
ex3 = "Can you write me a small poem?"
ex4 = [["What is this video about?", "https://youtu.be/_5SpM-QcccU?si=eEpleCQLAqDWGron"], "This is a cooking video", "Summarize it"]

from IPython.display import Markdown

Markdown(get_repr(mk_contents(ex1)))

[0]

• role: user
• parts:
  parts[0]

  • text: Hi I am Miko
  parts[1]

  • text: Hi Miko, how are you?
  parts[2]

  • text: What is my name again?

Markdown(get_repr(mk_contents(ex2)))

[0]

• role: user
• parts:
  parts[0]

  • text: What is this video about?
  parts[1]

  • file_data:
    • file_uri: https://youtu.be/_5SpM-QcccU?si=eEpleCQLAqDWGron
    • mime_type: video/*

Markdown(get_repr(mk_contents(ex3)))

[0]

• role: user
• parts:
  parts[0]

  • text: Can you write me a small poem?

Markdown(get_repr(mk_contents(ex4)))

[0]

• role: user
• parts:
  parts[0]

  • text: What is this video about?
  parts[1]

  • file_data:
    • file_uri: https://youtu.be/_5SpM-QcccU?si=eEpleCQLAqDWGron
    • mime_type: video/*

[1]

• role: model
• parts:
  parts[0]

  • text: This is a cooking video

[2]

• role: user
• parts:
  parts[0]

  • text: Summarize it

Compatibility with msglm

To be able to be swapped instead of Claudette or Cosette, we need to build a mk_msg and mk_msgs function for compatibility

---

source

mk_msgs

 mk_msgs (msgs:list|str, *args, api:str='openai', **kw)

Create a list of messages compatible with the GenAI sdk

def mk_msg(content: list | str | types.Content, role:str='user', *args, api='genai', **kw):
    """Create a `Content` object from the actual content (GenAI's equivalent of a Message)"""
    c = kw.get('client', genai.Client(api_key=os.environ['GEMINI_API_KEY']))
    return mk_content(content, role, cli=c)


def mk_msgs(msgs: list | str, *args, api:str="openai", **kw) -> list:
    "Create a list of messages compatible with the GenAI sdk"
    if isinstance(msgs, str): msgs = [msgs]
    return [mk_msg(o, ('user', 'model')[i % 2], *args, api=api, **kw) for i, o in enumerate(msgs)]

---

source

mk_msg

 mk_msg (content:list|str|google.genai.types.Content, role:str='user',
         *args, api='genai', **kw)

Create a Content object from the actual content (GenAI’s equivalent of a Message)

mk_msg(["In one sentence, what is this?", "../examples/DeepSeek_R1.pdf"])

• role: user
• parts:
  parts[0]

  • text: In one sentence, what is this?
  parts[1]

  • file_data:
    • file_uri: https://generativelanguage.googleapis.com/v1beta/files/4zuvu0fhu5ow
    • mime_type: application/pdf

import httpx

img_url = "https://claudette.answer.ai/index_files/figure-html/cell-35-output-1.jpeg"
img = httpx.get(img_url).content

mk_msg(["What is this?", img])

• role: user
• parts:
  parts[0]

  • text: What is this?
  parts[1]

  • inline_data:
    • data: b’10JFIF…’
    • mime_type: image/jpeg

c.models.generate_content(model=models[0], contents=mk_msgs([["What is this?", img]]))

That is a picture of a Cavalier King Charles Spaniel puppy. It’s a small breed of dog known for being affectionate and good companions. The puppy in the image has the classic Cavalier coloring of white and chestnut.

• usage_metadata: Cached: 0; In: 262; Out: 45; Total: 307
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.693117904663086
  • content:
    • role: model
    • parts:
      parts[0]

      • text: That is a picture of a Cavalier King Charles Spaniel puppy. It’s a small breed of dog known for being affectionate and good companions. The puppy in the image has the classic Cavalier coloring of white and chestnut.
  • finish_reason: FinishReason.STOP

msgs = ["Hi, I am Miko", 
        "YO! MIKO! HOW ARE YOU MY FREN?", 
        "Great, thank you. Do you remember my name?"]

c.models.generate_content(model=models[0], contents=mk_msgs(msgs))

I sure do, Miko! I remembered it from our last interaction. How can I help you today?

• usage_metadata: Cached: 0; In: 28; Out: 22; Total: 50
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.3646076809276234
  • content:
    • role: model
    • parts:
      parts[0]

      • text: I sure do, Miko! I remembered it from our last interaction. How can I help you today?
  • finish_reason: FinishReason.STOP

Cost and usage tracking

---

cost’]

*Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*

@patch(as_prop=True)
def use(self: genai.models.Models | genai.models.AsyncModels): return getattr(self, "_u", usage())

@patch(as_prop=True)
def cost(self: genai.models.Models | genai.models.AsyncModels): return getattr(self, "_cost", 0)


@patch(as_prop=True)
def use(self: genai.Client | genai.client.AsyncClient): return self.models.use

@patch(as_prop=True)
def cost(self: genai.Client | genai.client.AsyncClient): return self.models.cost

---

use’]

*Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*

---

cost’]

*Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*

---

use’]

*Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*

---

result_content’]

*Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*

@patch
def _r(self: genai.models.Models, r, think=None):
    """Process a complete model result, storing cost and usage on the `Models` instance."""
    self.result = r
    if think is not None: r._thinking = think
    self.result_content = [nested_idx(r, "candidates", 0, "content")]
    self._u = self.use + getattr(r, "usage_metadata", usage())
    self._cost = self.cost + r.cost
    for func in getattr(self, 'post_cbs', []): func(r)
    return r

@patch
async def _r(self: genai.models.AsyncModels, _ar, think=None):
    """Process an awaitable complete model result, storing cost and usage on the `Models` instance."""
    r = await _ar
    if think is not None: r._thinking = think
    self.result = r
    self.result_content = [nested_idx(r, "candidates", 0, "content")]
    self._u = self.use + getattr(r, "usage_metadata", usage())
    self._cost = self.cost + r.cost
    for func in getattr(self, 'post_cbs', []): func(r)
    return r

@patch(as_prop=True)
def result(self: genai.Client | genai.client.AsyncClient): return nested_idx(self, "models", "result")

@patch(as_prop=True)
def result_content(self: genai.Client | genai.client.AsyncClient): return nested_idx(self, "models", "result_content")

---

result’]

*Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*

We call _r after each generation has been completed (both for Gemini and Imagen models) to keep track of token usage and costs as well as storing the latest response from the model.

c.models._r(mr)
c.models._r(r)
c.models._r(mmr)

c.use, c.cost

(Cached: 0; In: 53; Out: 459; Total: 512, 0.1201721)

resp = c.models.generate_content(contents="Write a poem about otters", model=models[0])
c.models._r(resp)

c.use

Cached: 0; In: 59; Out: 728; Total: 787

c.result

A ripple, a gleam, a flash of dark fur,
An otter emerges, a whiskered blur.
From riverbank burrows, or kelp-forest deep,
Their playful existence, secrets they keep.

With sleek, streamlined bodies, built for the stream,
They dance with the currents, a liquid dream.
Webbed paws propel them, with effortless grace,
A ballet performed in their watery space.

They hunt with a fervor, a gleam in their eye,
For shellfish and fishes that swim swiftly by.
A stone on their chest, a makeshift small table,
They crack open their feast, a delectable fable.

They chatter and whistle, a language of clicks,
Communicating secrets with playful quick tricks.
They slide down the mudbanks, a joyful cascade,
In families they frolic, no longer afraid.

They hold to each other, afloat in the tide,
Connected and cozy, with nowhere to hide.
A symbol of joy, in their watery domain,
The otters are masters, of river and rain.

So watch for the sparkle, the splash and the call,
The otter’s bright spirit, enchanting us all.
A reminder to play, to connect and to thrive,
And find simple pleasures, in being alive.

• usage_metadata: Cached: 0; In: 6; Out: 269; Total: 275
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.6034687708744773
  • content:
    • role: model
    • parts:
      parts[0]

      • text: A ripple, a gleam, a flash of dark fur, An otter emerges, a whiskered blur. From riverbank burrows, or kelp-forest deep, Their playful existence, secrets they keep.

        With sleek, streamlined bodies, built for the stream, They dance with the currents, a liquid dream. Webbed paws propel them, with effortless grace, A ballet performed in their watery space.

        They hunt with a fervor, a gleam in their eye, For shellfish and fishes that swim swiftly by. A stone on their chest, a makeshift small table, They crack open their feast, a delectable fable.

        They chatter and whistle, a language of clicks, Communicating secrets with playful quick tricks. They slide down the mudbanks, a joyful cascade, In families they frolic, no longer afraid.

        They hold to each other, afloat in the tide, Connected and cozy, with nowhere to hide. A symbol of joy, in their watery domain, The otters are masters, of river and rain.

        So watch for the sparkle, the splash and the call, The otter’s bright spirit, enchanting us all. A reminder to play, to connect and to thrive, And find simple pleasures, in being alive.
  • finish_reason: FinishReason.STOP

Streaming generation

@patch(as_prop=True)
def _parts(self: types.GenerateContentResponse): return nested_idx(self, "candidates", 0, "content", "parts") or []
    

@patch
def _stream(self: genai.models.Models, s, think=None):
    all_parts = []
    for r in s:
        all_parts.extend(r._parts)
        yield r.text
    r.candidates[0].content.parts = all_parts
    self._r(r, think)

@patch
async def _astream(self: genai.models.AsyncModels, s, think=None):
    all_parts = []
    async for r in await s:
        all_parts.extend(r._parts)
        yield r.text
    r.candidates[0].content.parts = all_parts
    # Clunky, but _r expects an awaitable coroutine
    async def _w(x): return x
    await self._r(_w(r), think)

# This is for compatibility with Claudette. We want _stream(s) to be a coroutine, not an async generator
@patch
async def _stream(self: genai.models.AsyncModels, s, think): return self._astream(s, think)

To keep the behaviour coherent with Claudette’s when in streaming mode, we should only yield the text of the chunks, rather than the full response. The _stream method essentially replicates the text_stream of Anthropic’s SDK. Since there is no to Claude’s get_final_message we have to store the chunk parts as they are yielded. After the stream is exhausted, we substitute the saved parts into the final response (which contains the correct usage as well, and pass the result through _r)

@patch
def _gen(self:genai.models.Models, contents, model:str, config=None, stream:bool=False):
    gen_f = self.generate_content_stream if stream else self.generate_content
    r = gen_f(model=model, contents=contents, config=config)
    return self._stream(r) if stream else self._r(r)

We use the _gen method to get around the fact that streaming in genai is handled by different methods, rather than a parameter.

c.models._gen("Write me a short poem", model="gemini-2.0-flash")

The sun dips low, a fiery kiss,
Upon the clouds, in amethyst.
The day sighs deep, a gentle breeze,
Rustling softly through the trees.

And darkness waits, a velvet hand,
To spread its peace across the land.

• usage_metadata: Cached: 0; In: 5; Out: 54; Total: 59
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.43901051415337455
  • content:
    • role: model
    • parts:
      parts[0]

      • text: The sun dips low, a fiery kiss, Upon the clouds, in amethyst. The day sighs deep, a gentle breeze, Rustling softly through the trees.

        And darkness waits, a velvet hand, To spread its peace across the land.
  • finish_reason: FinishReason.STOP

for chunk in c.models._gen("Write me a poem", model="gemini-2.0-flash", stream=True):
    print(chunk, end="")

The wind whispers secrets through branches bare,
A symphony of rustling, thin and rare.
The sun, a muted gold, begins to wane,
Painting long shadows on the frosted lane.

A robin hops, a crimson breast so bright,
Against the somber hues of fading light.
The scent of woodsmoke curls, a gentle haze,
Reminding hearts of warmer, bygone days.

A single leaf, tenacious, holds its ground,
A stubborn sentinel, without a sound.
It clings to life, a fragile, fading green,
A silent testament to what has been.

And in the quiet hush, the world holds breath,
Awaiting slumber, conquering even death.
For even in the stillness, cold and deep,
A promise of renewal lies in sleep.

c.result

The wind whispers secrets through branches bare,
A symphony of rustling, thin and rare.
The sun, a muted gold, begins to wane,
Painting long shadows on the frosted lane.

A robin hops, a crimson breast so bright,
Against the somber hues of fading light.
The scent of woodsmoke curls, a gentle haze,
Reminding hearts of warmer, bygone days.

A single leaf, tenacious, holds its ground,
A stubborn sentinel, without a sound.
It clings to life, a fragile, fading green,
A silent testament to what has been.

And in the quiet hush, the world holds breath,
Awaiting slumber, conquering even death.
For even in the stillness, cold and deep,
A promise of renewal lies in sleep.

• usage_metadata: Cached: 0; In: 4; Out: 166; Total: 170
• model_version: gemini-2.0-flash
• candidates:
  candidates[0]

  • content:
    • role: model
    • parts:
      parts[0]

      • text: The
      parts[1]

      • text: wind
      parts[2]

      • text: whispers secrets through branches bare, A symphony of rustling, thin and rare
      parts[3]

      • text: . The sun, a muted gold, begins to wane, Painting
      parts[4]

      • text: long shadows on the frosted lane.

        A robin hops, a crimson breast so bright, Against the somber hues of fading light. The scent of wood
      parts[5]

      • text: smoke curls, a gentle haze, Reminding hearts of warmer, bygone days.

        A single leaf, tenacious, holds its ground, A stubborn sentinel
      parts[6]

      • text: , without a sound. It clings to life, a fragile, fading green, A silent testament to what has been.

        And in the quiet hush, the world holds breath, Awaiting slumber, conquering even death. For
      parts[7]

      • text: even in the stillness, cold and deep, A promise of renewal lies in sleep.
  • finish_reason: FinishReason.STOP

Other generation parameters

To handle the other generation parameters, we need to convert Claudettes’ parameters into GenerateContentConfigDict to be passed to the generation function.

@patch
def _genconf(self: genai.models.Models | genai.models.AsyncModels, **kw):
    """Builds a GenerateContentConfigDict from call parameters"""
    config= {k: v for k, v in kw.items() if k in types.GenerateContentConfigDict.__annotations__}
    if _sp := kw.get("sp", False) or kw.get('system_instruction', False) or getattr(self, 'sp', False):
        config['system_instruction'] = _sp 
    if _temp := kw.get("temp", False) or kw.get('temperature', False) or getattr(self, 'temp', False):
        config['temperature'] = _temp
    if maxtok := kw.get("maxtok", False): config['max_output_tokens'] = maxtok
    if stop := kw.get("stop", False): config['stop_sequences'] = [stop] if isinstance(stop, str) else stop

    model = kw.get('model', None)
    if tbudget := kw.get("maxthinktok", None) is not None and model in thinking_models: 
        config['thinking_config'] = {"thinking_budget": tbudget}

    if tools:= kw.get("tools", False):
        config['tools'] = tools
        tc = config.get('tool_config', dict())
        fcc = tc.get('function_calling_config', dict())
        fcc['mode'] = kw.get("tool_mode", 'AUTO')
        tc['function_calling_config'] = fcc
        config['tool_config']= tc
        
    if model in imagen_models and not getattr(self, "text_only", False):
        config['response_modalities'] = kw.get('response_modalities', ['Text', 'Image'])
        
    return config

We build a small helper function to help test the config generation

def g(client, inps, model, sp='', temp=0.6, maxtok=None, stream=False, stop=None, **kwargs):
    config = client.models._genconf(sp=sp, temp=temp, maxtok=maxtok, stop=stop, model=model, **kwargs)
    contents = mk_contents(inps, cli=client)
    return client.models._gen(inps, model, config, stream)

model = models[0]
model

'gemini-2.0-flash'

g(c, "give me a numbered list of 10 animals", model,
  stop="4", 
  sp='always talk in Spanish', 
  maxtok=10)

¡Claro que sí! Aquí tienes una lista

• usage_metadata: Cached: 0; In: 14; Out: 9; Total: 23
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.0456094311343299
  • content:
    • role: model
    • parts:
      parts[0]

      • text: ¡Claro que sí! Aquí tienes una lista
  • finish_reason: FinishReason.MAX_TOKENS

g(c, "give me a numbered list of 10 animals", model,
  stop="4", 
  sp='always talk in German')

Selbstverständlich! Hier ist eine nummerierte Liste mit 10 Tieren:

1. Hund (der)
2. Katze (die)
3. Elefant (der)

• usage_metadata: Cached: 0; In: 14; Out: 42; Total: 56
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.1104056267511277
  • content:
    • role: model
    • parts:
      parts[0]

      • text: Selbstverständlich! Hier ist eine nummerierte Liste mit 10 Tieren:

        1. Hund (der)
        2. Katze (die)
        3. Elefant (der)
  • finish_reason: FinishReason.STOP

g(c, "give me a numbered list of 10 animals", model,
  stop="4", sp = "Talk in piglatin exclusively")

Okay-ay, ere-hay is-thay a-ay umbered-nay ist-lay of-ay en-tay animals-ay:

1. Onday-Lay
2. At-Cay
3. Ird-Bay

• usage_metadata: Cached: 0; In: 15; Out: 54; Total: 69
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.11671152821293583
  • content:
    • role: model
    • parts:
      parts[0]

      • text: Okay-ay, ere-hay is-thay a-ay umbered-nay ist-lay of-ay en-tay animals-ay:

        1. Onday-Lay
        2. At-Cay
        3. Ird-Bay
  • finish_reason: FinishReason.STOP

Tools and function calling

There are two ways of managing function calling. The other is to actually build the function declaration. The first approach has the advantage of enabling automatic function calling, meaning that whenever the LLM decides that the function needs to be called, it will call and get the result back. The main drawback is that it realies on the types.FunctionDeclaration.from_callable method, which is quite limited (mainly, it does not add descriptions to the parameters, most likely relying on docstrings following Google’s style guide).

The second approach requires manually declaring the function, but this won’t be picked up by the automatic function calling, so requires manually enabling the function loop (extracting the function calls from the response, calling the function and passing it back to the LLM).

Tool prepping

def add1(
    a:int, # the 1st number to add
    b=0,   # the 2nd number to add
)->int:    # the result of adding `a` to `b`
    "Sums two numbers."
    return a+b

def add2(
    a:int, # the 1st number to add
    b:int=0,   # the 2nd number to add
)->int:    # the result of adding `a` to `b`
    "Sums two numbers."
    return a+b

def add3(
    a:int, # the 1st number to add
    b:int,   # the 2nd number to add
)->int:    # the result of adding `a` to `b`
    "Sums two numbers."
    return a+b

try:
    f_decl = types.FunctionDeclaration.from_callable(callable=add1, client=c)
except:
    try:
        f_decl = types.FunctionDeclaration.from_callable(callable=add2, client=c)
    except:
        f_decl = types.FunctionDeclaration.from_callable(callable=add3, client=c)
        

f_decl.to_json_dict()

{'description': 'Sums two numbers.',
 'name': 'add3',
 'parameters': {'properties': {'a': {'type': 'INTEGER'},
   'b': {'type': 'INTEGER'}},
  'type': 'OBJECT'}}

docments(add1, full=True, returns=False)

{ 'a': { 'anno': <class 'int'>,
         'default': <class 'inspect._empty'>,
         'docment': 'the 1st number to add'},
  'b': { 'anno': <class 'int'>,
         'default': 0,
         'docment': 'the 2nd number to add'}}

Notice that types.FunctionDeclaration.from_callable:

1. Cannot infer the parameter type from the default value (while docments can)
2. Does not use the default values at all: in fact adding default values to a function declaration passed to the Gemini API will raise an error, although the LLM would be able to use (and in fact does use if it’s passed), the “required” field of the “parameters”, which again could be inferred.

---

source

goog_doc

 goog_doc (f:<built-infunctioncallable>)

Builds the docstring for a docment style function following Google style guide

	Type	Details
f	callable	A docment style function
Returns	str	Google style docstring

When passing a function as a tool, the API will only access the function signature and docstring to build the FunctionDeclaration, so unless they are part of the docstring, the LLM has no way of knowing what the arguments or the returned value are. Assuming that Gemini models will have seen quite a lot of google code, and considering the examples in the documentation, it’s probably a good idea to turn the docstrings of tools into a format compatible with the style guide.

print(goog_doc(goog_doc))

Builds the docstring for a docment style function following Google style guide

Args:
    f: A docment style function

Returns:
    Google style docstring

---

source

prep_tool

 prep_tool (f:<built-infunctioncallable>, as_decl:bool=False,
            googlify_docstring:bool=True)

Optimizes a dunction for function calling with the Gemini api. Best suited for docments style functions.

	Type	Default	Details
f	callable		The function to be passed to the LLM
as_decl	bool	False	Return an enriched genai.types.FunctionDeclaration?
googlify_docstring	bool	True	Use docments to rewrite the docstring following Google Style Guide?

def _geminify(f: callable) -> callable:
    """Makes a function suitable to be turned into a function declaration: 
    infers argument types from default values and removes the values from the signature"""
    docs = docments(f, full=True)
    new_params = [inspect.Parameter(name=n,
                                    kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
                                    annotation=i.anno) for n, i in docs.items() if n != 'return']

        
    @wraps(f)
    def wrapper(*args, **kwargs):
        return f(*args, **kwargs)
    
    wrapper.__signature__ = inspect.Signature(new_params, return_annotation=docs['return']['anno'])
    wrapper.__annotations__ = {n: i['anno'] for n, i in docs.items() if n != 'return'}
    return wrapper


def prep_tool(f:callable, # The function to be passed to the LLM
             as_decl:bool=False,  # Return an enriched genai.types.FunctionDeclaration?
             googlify_docstring:bool=True): # Use docments to rewrite the docstring following Google Style Guide? 
    """Optimizes a dunction for function calling with the Gemini api. Best suited for docments style functions."""
    docs = goog_doc(f) if googlify_docstring else f.__doc__
    _f = _geminify(f)
    _f.__doc__ = docs
    if not as_decl: return _f
    f_decl = types.FunctionDeclaration.from_callable_with_api_option(callable=_f, api_option='GEMINI_API')
    for par, desc in docments(f, returns=False).items():
        if desc: f_decl.parameters.properties[par].description = desc
    required_params = [p for p, d in docments(f, full=True, returns=False).items() if d['default'] == inspect._empty]
    if hasattr(f_decl.parameters, "required"): f_decl.parameters.required = required_params
    return f_decl

To prepare a function to be used as a function declaration, it needs to be stripped of default values and all the arguments need to be annotated. Turning the docstrings in a Google compatible format makes sure that the result can be used for automatic function calling. We rely on FunctionDeclaration.from_callable either implicitly (when passing the prepped function to the LLM) or implicitly to do the necessary type conversions of the annotations (i.e. turning a float into NUMBER, a str into STRING etc.). If building the function declaration explicitly, we can also enrich it with information from the original function (namely the presence of default values and the arguments docments that can be added paramters objects).

x = prep_tool(add1, as_decl=True)
x

• name: add1
• parameters:
  • required:
    required[0]

    a
  • properties:
    • a:
      • description: the 1st number to add
      • type: Type.INTEGER
    • b:
      • description: the 2nd number to add
      • type: Type.INTEGER
  • type: Type.OBJECT

• description: Sums two numbers.

  Args: a: the 1st number to add b: the 2nd number to add

  Returns: the result of adding a to b

def g(client, inps, model, sp='', temp=0.6, maxtok=None, stream=False, stop=None, **kwargs):
    config = client.models._genconf(sp=sp, temp=temp, maxtok=maxtok, stop=stop, model=model, use_afc=False, **kwargs)
    contents = mk_contents(inps, cli=client)
    return client.models._gen(inps, model, config, stream)

model = models[0]
model

'gemini-2.0-flash'

tool = types.Tool(function_declarations=[x])

a,b = 694599,645893212
pr = f"What is {a}+{b}?"


respt = g(c, pr, model='gemini-2.0-flash', tools=[tool])
respt

• add1(b=645893212, a=694599)

• usage_metadata: Cached: 0; In: 84; Out: 4; Total: 88
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: 1.3451382983475924e-05
  • content:
    • role: model
    • parts:
      parts[0]

      • function_call:
        • name: add1
        • args:
          • b: 645893212
          • a: 694599
  • finish_reason: FinishReason.STOP

---

source

mk_fres_content

 mk_fres_content (fres)

def f_result(fname, fargs, ns=None):
    try: return {"result": call_func(fname, fargs, ns or globals())}
    except Exception as e: return {'error': str(e)}

def f_results(fcalls, ns=None):
    return [{"name": c.name, "response": f_result(c.name, c.args, ns)} for c in fcalls]

def mk_fres_content(fres):
    return types.Content(role='tool', parts=[types.Part.from_function_response(**d) for d in fres])

---

source

f_results

 f_results (fcalls, ns=None)

---

source

f_result

 f_result (fname, fargs, ns=None)

These three function are more or less what the SDK automatic function calling does under the hood, turning the function call response form the LLM into an actual fucnction call and executing the response (or exception raised) into a Part ready to be sent to the LLM again.

mk_fres_content(f_results(respt.function_calls))

• role: tool
• parts:
  parts[0]

  • function_response:
    • name: add1
    • response:
      • result: 646587811

@patch
def _call_tools(self: genai.models.Models | genai.models.AsyncModels, r):
    if r.function_calls:
        self.result_content.append(mk_fres_content(f_results(r.function_calls, ns=getattr(self, "_tools", None))))

If the response from an LLM is a function call, we want to make sure to actually call the functions, and append the results to the tool results.

---

source

prep_tools

 prep_tools (tools, toolify_everything=False)

def prep_tools(tools, toolify_everything=False):
    funcs = [prep_tool(f, as_decl=toolify_everything) for f in tools if inspect.isfunction(f) or inspect.ismethod(f)]
    if toolify_everything: funcs = [types.Tool(function_declarations=[f]) for f in funcs]
    tools_ = [t for t in tools if isinstance(t, types.Tool)]
    class_tools = [types.Tool(function_declarations=[prep_tool(f, as_decl=True)]) for f in tools if inspect.isclass(f)]
    return funcs + tools_ + class_tools

Since we can pass several tools at once, and functions can be handled directly using the automated function calling from the SDK itself, in order to keep the API consistent with Claudette and Cosette, we need to add an intermediate layer to prepare the tools. Notice that this is defining each single function as a tool, while in principle we could group several into a tool (so that we can force the LLM to use a subset of tools).

a,b = 1232414,9415135
pr = f"What is {a}+{b}?"

c.models._tools=[add1]
c.models.post_cbs = [c.models._call_tools]

respt = g(c, pr, model=model, tools=[tool])
respt

• add1(a=1232414, b=9415135)

• usage_metadata: Cached: 0; In: 83; Out: 4; Total: 87
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: 2.057495294138789e-06
  • content:
    • role: model
    • parts:
      parts[0]

      • function_call:
        • name: add1
        • args:
          • a: 1232414
          • b: 9415135
  • finish_reason: FinishReason.STOP

g(c, [pr] + c.result_content, model=model, tools=[tool])

1232414+9415135 is 10647549.

• usage_metadata: Cached: 0; In: 90; Out: 26; Total: 116
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.0005261174474771207
  • content:
    • role: model
    • parts:
      parts[0]

      • text: 1232414+9415135 is 10647549.
  • finish_reason: FinishReason.STOP

Automatic Function Calling

If instead of tools, we pass functions, we can rely on the SDK Automatic function calling, which essentially completes the whole tool loop by itself (checking for errors as well). The main drawback is that it is more limited in terms of function parameters types and it completely relies on the docstring of the function (although we turn the docments comments into a more complete docstring while prepping the function). In other words, when automatically building turning the function into a tool, the parameters descriptions are not set when using AFC. It is uncler how much this might affect the function calling performance

def sums(
    a:int,  # First number to sum 
    b=1 # Second number to sum
) -> int: # The sum of the inputs
    "Adds two numbers"
    print(f"Finding the sum of {a} and {b}")
    return a + b

a,b = 604542,6458932
pr = f"What is {a}+{b}?"
pr

'What is 604542+6458932?'

def mults(
    a:int,  # First thing to multiply
    b:int=1 # Second thing to multiply
) -> int: # The product of the inputs
    "Multiplies a * b."
    print(f"Finding the product of {a} and {b}")
    return a * b

pr = f'Calculate ({a}+{b})*2'
pr

'Calculate (604542+6458932)*2'

resp = g(c, pr, model=model, tools=prep_tools([sums, mults]))
resp

Finding the sum of 604542 and 6458932
Finding the product of 7063474 and 2

(604542+6458932)*2 = 14126948

• usage_metadata: Cached: 0; In: 104; Out: 28; Total: 132
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
  automatic_function_calling_history[0]

  • parts:
    parts[0]

    • text: Calculate (604542+6458932)*2
  automatic_function_calling_history[1]

  • role: model
  • parts:
    parts[0]

    • function_call:
      • name: sums
      • args:
        • a: 604542
        • b: 6458932
  automatic_function_calling_history[2]

  • role: user
  • parts:
    parts[0]

    • function_response:
      • name: sums
      • response:
        • result: 7063474
  automatic_function_calling_history[3]

  • role: model
  • parts:
    parts[0]

    • function_call:
      • name: mults
      • args:
        • b: 2
        • a: 7063474
  automatic_function_calling_history[4]

  • role: user
  • parts:
    parts[0]

    • function_response:
      • name: mults
      • response:
        • result: 14126948
• candidates:
  candidates[0]

  • avg_logprobs: -0.00044459816334503036
  • content:
    • role: model
    • parts:
      parts[0]

      • text: (604542+6458932)*2 = 14126948
  • finish_reason: FinishReason.STOP

resp.automatic_function_calling_history

[UserContent(parts=[Part(video_metadata=None, thought=None, code_execution_result=None, executable_code=None, file_data=None, function_call=None, function_response=None, inline_data=None, text='Calculate (604542+6458932)*2')], role='user'),
 Content(parts=[Part(video_metadata=None, thought=None, code_execution_result=None, executable_code=None, file_data=None, function_call=FunctionCall(id=None, args={'a': 604542, 'b': 6458932}, name='sums'), function_response=None, inline_data=None, text=None)], role='model'),
 Content(parts=[Part(video_metadata=None, thought=None, code_execution_result=None, executable_code=None, file_data=None, function_call=None, function_response=FunctionResponse(id=None, name='sums', response={'result': 7063474}), inline_data=None, text=None)], role='user'),
 Content(parts=[Part(video_metadata=None, thought=None, code_execution_result=None, executable_code=None, file_data=None, function_call=FunctionCall(id=None, args={'b': 2, 'a': 7063474}, name='mults'), function_response=None, inline_data=None, text=None)], role='model'),
 Content(parts=[Part(video_metadata=None, thought=None, code_execution_result=None, executable_code=None, file_data=None, function_call=None, function_response=FunctionResponse(id=None, name='mults', response={'result': 14126948}), inline_data=None, text=None)], role='user')]

g(c, "What is a good game to play with a dog on a rainy day?", model=model, tools=prep_tools([sums, mults]))

I am sorry, I am unable to help with that. I can only calculate sums and products.

• usage_metadata: Cached: 0; In: 89; Out: 20; Total: 109
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.22297334671020508
  • content:
    • role: model
    • parts:
      parts[0]

      • text: I am sorry, I am unable to help with that. I can only calculate sums and products.
  • finish_reason: FinishReason.STOP

Notice how if passing tools to the calls, Gemini assumes that its sole purpose is to call those tools.

g(c, "What is a good game to play with a dog on a rainy day?", model=model, tools=prep_tools([sums, mults]), tool_mode='NONE')

Okay, here are some fun and engaging games you can play with your dog indoors on a rainy day, catering to different energy levels and preferences:

For the Energetic Pup:

* Indoor Fetch/Hallway Fetch: If you have a long hallway or a spacious room, you can still play fetch! Use a soft toy or a rolled-up sock to prevent damage. Keep the throws short and controlled.
* Tug-of-War: A classic! Tug-of-war is a great way to burn energy and build a bond. Make sure you let your dog win sometimes and avoid jerking the toy too hard to protect their teeth and neck.
* Agility Course (DIY): Use household items like pillows, blankets draped over chairs, tunnels made from cardboard boxes, or even a broom laid across two objects to create a mini agility course. Guide your dog through it using treats and praise. Start slow and gradually increase the difficulty.
* Find the Treat/Toy: Hide treats or a favorite toy around the house and encourage your dog to sniff them out. Start with easy hides and gradually make them more challenging.
* Flirt Pole: If you have a flirt pole (a toy attached to a long pole), you can use it indoors (carefully!). This is a great way to get a dog moving and engaged. Make sure you have enough space and be mindful of your surroundings.

For the Mentally Stimulated Dog:

* Puzzle Toys: These are a lifesaver on rainy days! There are many different types, from simple treat-dispensing balls to more complex puzzles that require your dog to solve problems to get to the reward. Examples include:
* Kong Wobbler: A classic that dispenses treats as it wobbles.
* Nina Ottosson Puzzles: A popular brand with various difficulty levels.
* Snuffle Mats: A mat with fabric strips where you can hide treats for your dog to find.
* Training Games: Rainy days are perfect for reinforcing basic commands or teaching new tricks. Keep training sessions short, positive, and reward-based.
* “Sit,” “Stay,” “Come,” “Down” Practice these commands in different locations around the house.
* “Leave It” A crucial command for safety and impulse control.
* “Spin,” “Shake,” “Play Dead” Fun tricks that impress and engage your dog.
* Name Game: Teach your dog the names of their toys. Hold up a toy, say its name, and reward your dog when they touch it. Gradually increase the number of toys they have to differentiate between.
* “Which Hand?” Hide a treat in one hand and let your dog sniff both hands. When they indicate which hand has the treat, reward them.

For the Relaxed Dog (or to wind down after playtime):

* Massage/Grooming: A gentle massage or grooming session can be very relaxing for your dog.
* Cuddle Time: Sometimes, the best rainy day activity is simply cuddling up on the couch with your furry friend.
* Listen to Calming Music/Sounds: There are playlists specifically designed for dogs that can help them relax.
* Chew Toy Session: Provide a long-lasting chew toy to keep your dog occupied and help them relax.

Important Considerations:

* Space: Consider the size of your home and choose games that fit the available space.
* Your Dog’s Personality: Tailor the games to your dog’s individual preferences and energy levels. Some dogs love fetch, while others prefer puzzle toys.
* Safety: Make sure the environment is safe for your dog. Remove any hazards and use soft toys to prevent injuries.
* Supervision: Always supervise your dog during playtime, especially when using new toys or playing new games.
* Breaks: Give your dog breaks during playtime to prevent them from getting overtired.
* End on a Positive Note: Always end playtime with praise and a reward.

Have fun playing with your dog on those rainy days! A little creativity can go a long way in keeping your furry friend happy and entertained.

• usage_metadata: Cached: 0; In: 15; Out: 914; Total: 929
• model_version: gemini-2.0-flash
• automatic_function_calling_history:
• candidates:
  candidates[0]

  • avg_logprobs: -0.2559830312916695
  • content:
    • role: model
    • parts:
      parts[0]

      • text: Okay, here are some fun and engaging games you can play with your dog indoors on a rainy day, catering to different energy levels and preferences:

        For the Energetic Pup:

        • Indoor Fetch/Hallway Fetch: If you have a long hallway or a spacious room, you can still play fetch! Use a soft toy or a rolled-up sock to prevent damage. Keep the throws short and controlled.
        • Tug-of-War: A classic! Tug-of-war is a great way to burn energy and build a bond. Make sure you let your dog win sometimes and avoid jerking the toy too hard to protect their teeth and neck.
        • Agility Course (DIY): Use household items like pillows, blankets draped over chairs, tunnels made from cardboard boxes, or even a broom laid across two objects to create a mini agility course. Guide your dog through it using treats and praise. Start slow and gradually increase the difficulty.
        • Find the Treat/Toy: Hide treats or a favorite toy around the house and encourage your dog to sniff them out. Start with easy hides and gradually make them more challenging.
        • Flirt Pole: If you have a flirt pole (a toy attached to a long pole), you can use it indoors (carefully!). This is a great way to get a dog moving and engaged. Make sure you have enough space and be mindful of your surroundings.

        For the Mentally Stimulated Dog:

        • Puzzle Toys: These are a lifesaver on rainy days! There are many different types, from simple treat-dispensing balls to more complex puzzles that require your dog to solve problems to get to the reward. Examples include:
          • Kong Wobbler: A classic that dispenses treats as it wobbles.
          • Nina Ottosson Puzzles: A popular brand with various difficulty levels.
          • Snuffle Mats: A mat with fabric strips where you can hide treats for your dog to find.
        • Training Games: Rainy days are perfect for reinforcing basic commands or teaching new tricks. Keep training sessions short, positive, and reward-based.
          • “Sit,” “Stay,” “Come,” “Down” Practice these commands in different locations around the house.
          • “Leave It” A crucial command for safety and impulse control.
          • “Spin,” “Shake,” “Play Dead” Fun tricks that impress and engage your dog.
        • Name Game: Teach your dog the names of their toys. Hold up a toy, say its name, and reward your dog when they touch it. Gradually increase the number of toys they have to differentiate between.
        • “Which Hand?” Hide a treat in one hand and let your dog sniff both hands. When they indicate which hand has the treat, reward them.

        For the Relaxed Dog (or to wind down after playtime):

        • Massage/Grooming: A gentle massage or grooming session can be very relaxing for your dog.
        • Cuddle Time: Sometimes, the best rainy day activity is simply cuddling up on the couch with your furry friend.
        • Listen to Calming Music/Sounds: There are playlists specifically designed for dogs that can help them relax.
        • Chew Toy Session: Provide a long-lasting chew toy to keep your dog occupied and help them relax.

        Important Considerations:

        • Space: Consider the size of your home and choose games that fit the available space.
        • Your Dog’s Personality: Tailor the games to your dog’s individual preferences and energy levels. Some dogs love fetch, while others prefer puzzle toys.
        • Safety: Make sure the environment is safe for your dog. Remove any hazards and use soft toys to prevent injuries.
        • Supervision: Always supervise your dog during playtime, especially when using new toys or playing new games.
        • Breaks: Give your dog breaks during playtime to prevent them from getting overtired.
        • End on a Positive Note: Always end playtime with praise and a reward.
        Have fun playing with your dog on those rainy days! A little creativity can go a long way in keeping your furry friend happy and entertained.
  • finish_reason: FinishReason.STOP