types: relax type for tools (#550)

Remove unused `messages` variable from `thinking-generate` example

README.md

@@ -5,7 +5,7 @@ The Ollama Python library provides the easiest way to integrate Python 3.8+ proj
 ## Prerequisites
 
 - [Ollama](https://ollama.com/download) should be installed and running
-- Pull a model to use with the library: `ollama pull <model>` e.g. `ollama pull llama3.2`
+- Pull a model to use with the library: `ollama pull <model>` e.g. `ollama pull gemma3`
   - See [Ollama.com](https://ollama.com/search) for more information on the models available.
 
 ## Install
@@ -20,7 +20,7 @@ pip install ollama
 from ollama import chat
 from ollama import ChatResponse
 
-response: ChatResponse = chat(model='llama3.2', messages=[
+response: ChatResponse = chat(model='gemma3', messages=[
   {
     'role': 'user',
     'content': 'Why is the sky blue?',
@@ -41,7 +41,7 @@ Response streaming can be enabled by setting `stream=True`.
 from ollama import chat
 
 stream = chat(
-    model='llama3.2',
+    model='gemma3',
     messages=[{'role': 'user', 'content': 'Why is the sky blue?'}],
     stream=True,
 )
@@ -61,7 +61,7 @@ client = Client(
   host='http://localhost:11434',
   headers={'x-some-header': 'some-value'}
 )
-response = client.chat(model='llama3.2', messages=[
+response = client.chat(model='gemma3', messages=[
   {
     'role': 'user',
     'content': 'Why is the sky blue?',
@@ -79,7 +79,7 @@ from ollama import AsyncClient
 
 async def chat():
   message = {'role': 'user', 'content': 'Why is the sky blue?'}
-  response = await AsyncClient().chat(model='llama3.2', messages=[message])
+  response = await AsyncClient().chat(model='gemma3', messages=[message])
 
 asyncio.run(chat())
 ```
@@ -92,7 +92,7 @@ from ollama import AsyncClient
 
 async def chat():
   message = {'role': 'user', 'content': 'Why is the sky blue?'}
-  async for part in await AsyncClient().chat(model='llama3.2', messages=[message], stream=True):
+  async for part in await AsyncClient().chat(model='gemma3', messages=[message], stream=True):
     print(part['message']['content'], end='', flush=True)
 
 asyncio.run(chat())
@@ -105,13 +105,13 @@ The Ollama Python library's API is designed around the [Ollama REST API](https:/
 ### Chat
 
 ```python
-ollama.chat(model='llama3.2', messages=[{'role': 'user', 'content': 'Why is the sky blue?'}])
+ollama.chat(model='gemma3', messages=[{'role': 'user', 'content': 'Why is the sky blue?'}])
 ```
 
 ### Generate
 
 ```python
-ollama.generate(model='llama3.2', prompt='Why is the sky blue?')
+ollama.generate(model='gemma3', prompt='Why is the sky blue?')
 ```
 
 ### List
@@ -123,49 +123,49 @@ ollama.list()
 ### Show
 
 ```python
-ollama.show('llama3.2')
+ollama.show('gemma3')
 ```
 
 ### Create
 
 ```python
-ollama.create(model='example', from_='llama3.2', system="You are Mario from Super Mario Bros.")
+ollama.create(model='example', from_='gemma3', system="You are Mario from Super Mario Bros.")
 ```
 
 ### Copy
 
 ```python
-ollama.copy('llama3.2', 'user/llama3.2')
+ollama.copy('gemma3', 'user/gemma3')
 ```
 
 ### Delete
 
 ```python
-ollama.delete('llama3.2')
+ollama.delete('gemma3')
 ```
 
 ### Pull
 
 ```python
-ollama.pull('llama3.2')
+ollama.pull('gemma3')
 ```
 
 ### Push
 
 ```python
-ollama.push('user/llama3.2')
+ollama.push('user/gemma3')
 ```
 
 ### Embed
 
 ```python
-ollama.embed(model='llama3.2', input='The sky is blue because of rayleigh scattering')
+ollama.embed(model='gemma3', input='The sky is blue because of rayleigh scattering')
 ```
 
 ### Embed (batch)
 
 ```python
-ollama.embed(model='llama3.2', input=['The sky is blue because of rayleigh scattering', 'Grass is green because of chlorophyll'])
+ollama.embed(model='gemma3', input=['The sky is blue because of rayleigh scattering', 'Grass is green because of chlorophyll'])
 ```
 
 ### Ps

examples/README.md

@@ -25,6 +25,11 @@ See [ollama/docs/api.md](https://github.com/ollama/ollama/blob/main/docs/api.md)
 ### Tools/Function Calling - Call a function with a model
 - [tools.py](tools.py) - Simple example of Tools/Function Calling
 - [async-tools.py](async-tools.py)
+- [multi-tool.py](multi-tool.py) - Using multiple tools, with thinking enabled
+
+ #### gpt-oss
+- [gpt-oss-tools.py](gpt-oss-tools.py) - Using tools with gpt-oss
+- [gpt-oss-tools-stream.py](gpt-oss-tools-stream.py) - Using tools with gpt-oss, with streaming enabled
 
 
 ### Multimodal with Images - Chat with a multimodal (image chat) model
@@ -65,3 +70,6 @@ Requirement: `pip install tqdm`
 
 ### Thinking - Enable thinking mode for a model
 - [thinking.py](thinking.py)
+
+### Thinking (generate) - Enable thinking mode for a model
+- [thinking-generate.py](thinking-generate.py)

examples/async-chat.py

@@ -12,7 +12,7 @@ async def main():
   ]
 
   client = AsyncClient()
-  response = await client.chat('llama3.2', messages=messages)
+  response = await client.chat('gemma3', messages=messages)
   print(response['message']['content'])
 
 

examples/async-generate.py

@@ -5,7 +5,7 @@ import ollama
 
 async def main():
   client = ollama.AsyncClient()
-  response = await client.generate('llama3.2', 'Why is the sky blue?')
+  response = await client.generate('gemma3', 'Why is the sky blue?')
   print(response['response'])
 
 

examples/async-tools.py

@@ -76,7 +76,7 @@ async def main():
   if response.message.tool_calls:
     # Add the function response to messages for the model to use
     messages.append(response.message)
-    messages.append({'role': 'tool', 'content': str(output), 'name': tool.function.name})
+    messages.append({'role': 'tool', 'content': str(output), 'tool_name': tool.function.name})
 
     # Get final response from model with function outputs
     final_response = await client.chat('llama3.1', messages=messages)

examples/chat-stream.py

@@ -7,7 +7,5 @@ messages = [
   },
 ]
 
-for part in chat('llama3.2', messages=messages, stream=True):
+for part in chat('gemma3', messages=messages, stream=True):
   print(part['message']['content'], end='', flush=True)
-
-print()

examples/chat-with-history.py

@@ -22,7 +22,7 @@ messages = [
 while True:
   user_input = input('Chat with history: ')
   response = chat(
-    'llama3.2',
+    'gemma3',
     messages=[*messages, {'role': 'user', 'content': user_input}],
   )
 

examples/chat.py

@@ -7,5 +7,5 @@ messages = [
   },
 ]
 
-response = chat('llama3.2', messages=messages)
+response = chat('gemma3', messages=messages)
 print(response['message']['content'])

examples/create.py

@@ -3,7 +3,7 @@ from ollama import Client
 client = Client()
 response = client.create(
   model='my-assistant',
-  from_='llama3.2',
+  from_='gemma3',
   system='You are mario from Super Mario Bros.',
   stream=False,
 )

examples/generate-stream.py

@@ -1,4 +1,4 @@
 from ollama import generate
 
-for part in generate('llama3.2', 'Why is the sky blue?', stream=True):
+for part in generate('gemma3', 'Why is the sky blue?', stream=True):
   print(part['response'], end='', flush=True)

examples/generate.py

@@ -1,4 +1,4 @@
 from ollama import generate
 
-response = generate('llama3.2', 'Why is the sky blue?')
+response = generate('gemma3', 'Why is the sky blue?')
 print(response['response'])

examples/gpt-oss-tools-stream.py

@@ -0,0 +1,77 @@
+import random
+from typing import Iterator
+
+from ollama import chat
+from ollama._types import ChatResponse
+
+
+def get_weather(city: str) -> str:
+  """
+  Get the current temperature for a city
+
+  Args:
+      city (str): The name of the city
+
+  Returns:
+      str: The current temperature
+  """
+  temperatures = list(range(-10, 35))
+
+  temp = random.choice(temperatures)
+
+  return f'The temperature in {city} is {temp}°C'
+
+
+def get_weather_conditions(city: str) -> str:
+  """
+  Get the weather conditions for a city
+
+  Args:
+      city (str): The name of the city
+
+  Returns:
+      str: The current weather conditions
+  """
+  conditions = ['sunny', 'cloudy', 'rainy', 'snowy', 'foggy']
+  return random.choice(conditions)
+
+
+available_tools = {'get_weather': get_weather, 'get_weather_conditions': get_weather_conditions}
+
+messages = [{'role': 'user', 'content': 'What is the weather like in London? What are the conditions in Toronto?'}]
+
+
+model = 'gpt-oss:20b'
+# gpt-oss can call tools while "thinking"
+# a loop is needed to call the tools and get the results
+final = True
+while True:
+  response_stream: Iterator[ChatResponse] = chat(model=model, messages=messages, tools=[get_weather, get_weather_conditions], stream=True)
+
+  for chunk in response_stream:
+    if chunk.message.content:
+      if not (chunk.message.thinking or chunk.message.thinking == '') and final:
+        print('\nFinal result: ')
+        final = False
+      print(chunk.message.content, end='', flush=True)
+    if chunk.message.thinking:
+      print(chunk.message.thinking, end='', flush=True)
+
+  print()
+
+  if chunk.message.tool_calls:
+    for tool_call in chunk.message.tool_calls:
+      function_to_call = available_tools.get(tool_call.function.name)
+      if function_to_call:
+        print('\nCalling tool: ', tool_call.function.name, 'with arguments: ', tool_call.function.arguments)
+        result = function_to_call(**tool_call.function.arguments)
+        print('Tool result: ', result + '\n')
+
+        messages.append(chunk.message)
+        messages.append({'role': 'tool', 'content': result, 'tool_name': tool_call.function.name})
+      else:
+        print(f'Tool {tool_call.function.name} not found')
+
+  else:
+    # no more tool calls, we can stop the loop
+    break

examples/gpt-oss-tools.py

@@ -0,0 +1,70 @@
+import random
+
+from ollama import chat
+from ollama._types import ChatResponse
+
+
+def get_weather(city: str) -> str:
+  """
+  Get the current temperature for a city
+
+  Args:
+      city (str): The name of the city
+
+  Returns:
+      str: The current temperature
+  """
+  temperatures = list(range(-10, 35))
+
+  temp = random.choice(temperatures)
+
+  return f'The temperature in {city} is {temp}°C'
+
+
+def get_weather_conditions(city: str) -> str:
+  """
+  Get the weather conditions for a city
+
+  Args:
+      city (str): The name of the city
+
+  Returns:
+      str: The current weather conditions
+  """
+  conditions = ['sunny', 'cloudy', 'rainy', 'snowy', 'foggy']
+  return random.choice(conditions)
+
+
+available_tools = {'get_weather': get_weather, 'get_weather_conditions': get_weather_conditions}
+
+messages = [{'role': 'user', 'content': 'What is the weather like in London? What are the conditions in Toronto?'}]
+
+
+model = 'gpt-oss:20b'
+# gpt-oss can call tools while "thinking"
+# a loop is needed to call the tools and get the results
+while True:
+  response: ChatResponse = chat(model=model, messages=messages, tools=[get_weather, get_weather_conditions])
+
+  if response.message.content:
+    print('Content: ')
+    print(response.message.content + '\n')
+  if response.message.thinking:
+    print('Thinking: ')
+    print(response.message.thinking + '\n')
+
+  if response.message.tool_calls:
+    for tool_call in response.message.tool_calls:
+      function_to_call = available_tools.get(tool_call.function.name)
+      if function_to_call:
+        result = function_to_call(**tool_call.function.arguments)
+        print('Result from tool call name: ', tool_call.function.name, 'with arguments: ', tool_call.function.arguments, 'result: ', result + '\n')
+
+        messages.append(response.message)
+        messages.append({'role': 'tool', 'content': result, 'tool_name': tool_call.function.name})
+      else:
+        print(f'Tool {tool_call.function.name} not found')
+
+  else:
+    # no more tool calls, we can stop the loop
+    break

examples/multi-tool.py

@@ -0,0 +1,88 @@
+import random
+from typing import Iterator
+
+from ollama import ChatResponse, Client
+
+
+def get_temperature(city: str) -> int:
+  """
+  Get the temperature for a city in Celsius
+
+  Args:
+    city (str): The name of the city
+
+  Returns:
+    int: The current temperature in Celsius
+  """
+  # This is a mock implementation - would need to use a real weather API
+  import random
+
+  if city not in ['London', 'Paris', 'New York', 'Tokyo', 'Sydney']:
+    return 'Unknown city'
+
+  return str(random.randint(0, 35)) + ' degrees Celsius'
+
+
+def get_conditions(city: str) -> str:
+  """
+  Get the weather conditions for a city
+  """
+  if city not in ['London', 'Paris', 'New York', 'Tokyo', 'Sydney']:
+    return 'Unknown city'
+  # This is a mock implementation - would need to use a real weather API
+  conditions = ['sunny', 'cloudy', 'rainy', 'snowy']
+  return random.choice(conditions)
+
+
+available_functions = {
+  'get_temperature': get_temperature,
+  'get_conditions': get_conditions,
+}
+
+
+cities = ['London', 'Paris', 'New York', 'Tokyo', 'Sydney']
+city = random.choice(cities)
+city2 = random.choice(cities)
+messages = [{'role': 'user', 'content': f'What is the temperature in {city}? and what are the weather conditions in {city2}?'}]
+print('----- Prompt:', messages[0]['content'], '\n')
+
+model = 'qwen3'
+client = Client()
+response: Iterator[ChatResponse] = client.chat(model, stream=True, messages=messages, tools=[get_temperature, get_conditions], think=True)
+
+for chunk in response:
+  if chunk.message.thinking:
+    print(chunk.message.thinking, end='', flush=True)
+  if chunk.message.content:
+    print(chunk.message.content, end='', flush=True)
+  if chunk.message.tool_calls:
+    for tool in chunk.message.tool_calls:
+      if function_to_call := available_functions.get(tool.function.name):
+        print('\nCalling function:', tool.function.name, 'with arguments:', tool.function.arguments)
+        output = function_to_call(**tool.function.arguments)
+        print('> Function output:', output, '\n')
+
+        # Add the assistant message and tool call result to the messages
+        messages.append(chunk.message)
+        messages.append({'role': 'tool', 'content': str(output), 'tool_name': tool.function.name})
+      else:
+        print('Function', tool.function.name, 'not found')
+
+print('----- Sending result back to model \n')
+if any(msg.get('role') == 'tool' for msg in messages):
+  res = client.chat(model, stream=True, tools=[get_temperature, get_conditions], messages=messages, think=True)
+  done_thinking = False
+  for chunk in res:
+    if chunk.message.thinking:
+      print(chunk.message.thinking, end='', flush=True)
+    if chunk.message.content:
+      if not done_thinking:
+        print('\n----- Final result:')
+        done_thinking = True
+      print(chunk.message.content, end='', flush=True)
+    if chunk.message.tool_calls:
+      # Model should be explaining the tool calls and the results in this output
+      print('Model returned tool calls:')
+      print(chunk.message.tool_calls)
+else:
+  print('No tool calls returned')

examples/multimodal-chat.py

@@ -11,7 +11,7 @@ path = input('Please enter the path to the image: ')
 # img = Path(path).read_bytes()
 
 response = chat(
-  model='llama3.2-vision',
+  model='gemma3',
   messages=[
     {
       'role': 'user',

examples/ps.py

@@ -1,7 +1,7 @@
 from ollama import ProcessResponse, chat, ps, pull
 
 # Ensure at least one model is loaded
-response = pull('llama3.2', stream=True)
+response = pull('gemma3', stream=True)
 progress_states = set()
 for progress in response:
   if progress.get('status') in progress_states:
@@ -12,7 +12,7 @@ for progress in response:
 print('\n')
 
 print('Waiting for model to load... \n')
-chat(model='llama3.2', messages=[{'role': 'user', 'content': 'Why is the sky blue?'}])
+chat(model='gemma3', messages=[{'role': 'user', 'content': 'Why is the sky blue?'}])
 
 
 response: ProcessResponse = ps()
@@ -23,4 +23,5 @@ for model in response.models:
   print('  Size: ', model.size)
   print('  Size vram: ', model.size_vram)
   print('  Details: ', model.details)
+  print('  Context length: ', model.context_length)
   print('\n')

examples/pull.py

@@ -3,7 +3,7 @@ from tqdm import tqdm
 from ollama import pull
 
 current_digest, bars = '', {}
-for progress in pull('llama3.2', stream=True):
+for progress in pull('gemma3', stream=True):
   digest = progress.get('digest', '')
   if digest != current_digest and current_digest in bars:
     bars[current_digest].close()

examples/structured-outputs-image.py

@@ -33,7 +33,7 @@ if not path.exists():
 
 # Set up chat as usual
 response = chat(
-  model='llama3.2-vision',
+  model='gemma3',
   format=ImageDescription.model_json_schema(),  # Pass in the schema for the response
   messages=[
     {

examples/thinking-generate.py

@@ -0,0 +1,6 @@
+from ollama import generate
+
+response = generate('deepseek-r1', 'why is the sky blue', think=True)
+
+print('Thinking:\n========\n\n' + response.thinking)
+print('\nResponse:\n========\n\n' + response.response)

examples/tools.py

@@ -74,7 +74,7 @@ if response.message.tool_calls:
 if response.message.tool_calls:
   # Add the function response to messages for the model to use
   messages.append(response.message)
-  messages.append({'role': 'tool', 'content': str(output), 'name': tool.function.name})
+  messages.append({'role': 'tool', 'content': str(output), 'tool_name': tool.function.name})
 
   # Get final response from model with function outputs
   final_response = chat('llama3.1', messages=messages)

ollama/_client.py

@@ -190,6 +190,7 @@ class Client(BaseClient):
     template: str = '',
     context: Optional[Sequence[int]] = None,
     stream: Literal[False] = False,
+    think: Optional[bool] = None,
     raw: bool = False,
     format: Optional[Union[Literal['', 'json'], JsonSchemaValue]] = None,
     images: Optional[Sequence[Union[str, bytes, Image]]] = None,
@@ -208,6 +209,7 @@ class Client(BaseClient):
     template: str = '',
     context: Optional[Sequence[int]] = None,
     stream: Literal[True] = True,
+    think: Optional[bool] = None,
     raw: bool = False,
     format: Optional[Union[Literal['', 'json'], JsonSchemaValue]] = None,
     images: Optional[Sequence[Union[str, bytes, Image]]] = None,
@@ -225,6 +227,7 @@ class Client(BaseClient):
     template: Optional[str] = None,
     context: Optional[Sequence[int]] = None,
     stream: bool = False,
+    think: Optional[bool] = None,
     raw: Optional[bool] = None,
     format: Optional[Union[Literal['', 'json'], JsonSchemaValue]] = None,
     images: Optional[Sequence[Union[str, bytes, Image]]] = None,
@@ -253,6 +256,7 @@ class Client(BaseClient):
         template=template,
         context=context,
         stream=stream,
+        think=think,
         raw=raw,
         format=format,
         images=list(_copy_images(images)) if images else None,

ollama/_types.py

@@ -79,7 +79,7 @@ class SubscriptableBaseModel(BaseModel):
     if key in self.model_fields_set:
       return True
 
-    if value := self.model_fields.get(key):
+    if value := self.__class__.model_fields.get(key):
       return value.default is not None
 
     return False
@@ -284,6 +284,9 @@ class Message(SubscriptableBaseModel):
   Valid image formats depend on the model. See the model card for more information.
   """
 
+  tool_name: Optional[str] = None
+  'Name of the executed tool.'
+
   class ToolCall(SubscriptableBaseModel):
     """
     Model tool calls.
@@ -310,7 +313,7 @@ class Message(SubscriptableBaseModel):
 
 
 class Tool(SubscriptableBaseModel):
-  type: Optional[Literal['function']] = 'function'
+  type: Optional[str] = 'function'
 
   class Function(SubscriptableBaseModel):
     name: Optional[str] = None
@@ -530,6 +533,7 @@ class ProcessResponse(SubscriptableBaseModel):
     size: Optional[ByteSize] = None
     size_vram: Optional[ByteSize] = None
     details: Optional[ModelDetails] = None
+    context_length: Optional[int] = None
 
   models: Sequence[Model]
 

ollama/_utils.py

@@ -79,11 +79,12 @@ def convert_function_to_tool(func: Callable) -> Tool:
     }
 
   tool = Tool(
+    type='function',
     function=Tool.Function(
       name=func.__name__,
       description=schema.get('description', ''),
       parameters=Tool.Function.Parameters(**schema),
-    )
+    ),
   )
 
   return Tool.model_validate(tool)

pyproject.toml

@@ -11,6 +11,7 @@ dependencies = [
     'pydantic>=2.9',
 ]
 dynamic = [ 'version' ]
+license = "MIT"
 
 [project.urls]
 homepage = 'https://ollama.com'
@@ -60,6 +61,7 @@ select = [
     'FLY', # flynt
     'RUF', # ruff-specific rules
 ]
+ignore = ['FBT001'] # Boolean-typed positional argument in function definition
 
 [tool.pytest.ini_options]
 addopts = ['--doctest-modules']

tests/test_client.py

@@ -8,7 +8,7 @@ from typing import Any
 
 import pytest
 from httpx import Response as httpxResponse
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 from pytest_httpserver import HTTPServer, URIPattern
 from werkzeug.wrappers import Request, Response
 
@@ -1136,10 +1136,11 @@ def test_copy_tools():
 
 
 def test_tool_validation():
-  # Raises ValidationError when used as it is a generator
-  with pytest.raises(ValidationError):
-    invalid_tool = {'type': 'invalid_type', 'function': {'name': 'test'}}
-    list(_copy_tools([invalid_tool]))
+  arbitrary_tool = {'type': 'custom_type', 'function': {'name': 'test'}}
+  tools = list(_copy_tools([arbitrary_tool]))
+  assert len(tools) == 1
+  assert tools[0].type == 'custom_type'
+  assert tools[0].function.name == 'test'
 
 
 def test_client_connection_error():