`Tool` and `Template` signatures should support polymorphic types

[eb8680]

We should take advantage of the type inference engine in internals/unification.py to allow Templates and Tools to be polymorphic:

@Template.define
def generate_similar[T](examples: Sequence[T]) -> T:
  """Generate another instance of the items in {examples}"""

...

@Tool.define
def extend_sequence[T](examples: Sequence[T], new_example: T) -> Sequence[T]:
  """Extends the input sequence with a new example"""
  ...

Here generate_similar can infer its type variable and enforce the resulting concrete type constraint, and extend_sequence can similarly have the type constraint on its arguments enforced immediately when a tool call to extend_sequence is generated.

[kiranandcode]

We don't yet support polymorphic tool calls.

[kiranandcode]

There is a design question to be asked here which is how to implement call_with_json_args (if we want to support it at all)

def call_with_json_args(
    tool: Tool, context: Mapping[str, Any], json_str: str
) -> OpenAIMessageContent:

The implementation of this is non trivial in the case of polymorphic functions.

Consider, generate_examples(example: Example[T]) -> Example[T] for example. The LLM will call this with arguments consisting of Examples[T] for some T.

call_with_json_args must somehow decode json_str to extract Example[T] for whichever concrete type T the LLM has called it with, but somehow without knowing which type T it is.

This decoding is ambiguous. For example if it sees 1 in the place of a value of type T inside Examples[T], does this correspond to Examples[int] and we decode 1 with int? or does it mean Examples[str] and we decode as is?

Alternatively we could wrap every polymorphic function signature in function_defintion and ask the LLM to explicitly provide the instantiation, but this would also require a decoding step "int" -> <class 'int'>

>>> pydantic.create_model("TypeInst", T=type).model_json_schema()
*** pydantic.errors.PydanticInvalidForJsonSchema: Cannot generate a JsonSchema for core_schema.IsInstanceSchema (<class 'type'>)

For further information visit https://errors.pydantic.dev/2.12/u/invalid-for-json-schema

[kiranandcode]

Following on from #505, we should have tests that check that polymorphic tools don't break functionality.