kiln-ai 0.18.0__py3-none-any.whl → 0.20.1__py3-none-any.whl

kiln_ai/adapters/model_adapters/base_adapter.py

@@ -3,10 +3,7 @@ from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass
 from typing import Dict, Tuple
 
-from kiln_ai.adapters.chat.chat_formatter import (
-    ChatFormatter,
-    get_chat_formatter,
-)
+from kiln_ai.adapters.chat.chat_formatter import ChatFormatter, get_chat_formatter
 from kiln_ai.adapters.ml_model_list import (
     KilnModelProvider,
     StructuredOutputMode,
@@ -28,8 +25,11 @@ from kiln_ai.datamodel import (
 )
 from kiln_ai.datamodel.datamodel_enums import ChatStrategy
 from kiln_ai.datamodel.json_schema import validate_schema_with_value_error
-from kiln_ai.datamodel.task import RunConfig
+from kiln_ai.datamodel.task import RunConfigProperties
+from kiln_ai.tools import KilnToolInterface
+from kiln_ai.tools.tool_registry import tool_from_id
 from kiln_ai.utils.config import Config
+from kiln_ai.utils.open_ai_types import ChatCompletionMessageParam
 
 
 @dataclass
@@ -51,33 +51,24 @@ class BaseAdapter(metaclass=ABCMeta):
     This abstract class provides the foundation for implementing model-specific adapters
     that can process tasks with structured or unstructured inputs/outputs. It handles
     input/output validation, prompt building, and run tracking.
-
-    Attributes:
-        prompt_builder (BasePromptBuilder): Builder for constructing prompts for the model
-        kiln_task (Task): The task configuration and metadata
-        output_schema (dict | None): JSON schema for validating structured outputs
-        input_schema (dict | None): JSON schema for validating structured inputs
     """
 
     def __init__(
         self,
-        run_config: RunConfig,
+        task: Task,
+        run_config: RunConfigProperties,
         config: AdapterConfig | None = None,
     ):
+        self.task = task
         self.run_config = run_config
         self.update_run_config_unknown_structured_output_mode()
-        self.prompt_builder = prompt_builder_from_id(
-            run_config.prompt_id, run_config.task
-        )
+        self.prompt_builder = prompt_builder_from_id(run_config.prompt_id, task)
         self._model_provider: KilnModelProvider | None = None
 
-        self.output_schema = self.task().output_json_schema
-        self.input_schema = self.task().input_json_schema
+        self.output_schema = task.output_json_schema
+        self.input_schema = task.input_json_schema
         self.base_adapter_config = config or AdapterConfig()
 
-    def task(self) -> Task:
-        return self.run_config.task
-
     def model_provider(self) -> KilnModelProvider:
         """
         Lazy load the model provider for this adapter.
@@ -155,23 +146,37 @@ class BaseAdapter(metaclass=ABCMeta):
                     f"response is not a string for non-structured task: {parsed_output.output}"
                 )
 
-        # Validate reasoning content is present (if reasoning)
-        if provider.reasoning_capable and (
-            not parsed_output.intermediate_outputs
-            or "reasoning" not in parsed_output.intermediate_outputs
+        # Validate reasoning content is present and required
+        # We don't require reasoning when using tools as models tend not to return any on the final turn (both Sonnet and Gemini).
+        trace_has_toolcalls = parsed_output.trace is not None and any(
+            message.get("role", None) == "tool" for message in parsed_output.trace
+        )
+        if (
+            provider.reasoning_capable
+            and (
+                not parsed_output.intermediate_outputs
+                or "reasoning" not in parsed_output.intermediate_outputs
+            )
+            and not (
+                provider.reasoning_optional_for_structured_output
+                and self.has_structured_output()
+            )
+            and not (trace_has_toolcalls)
         ):
             raise RuntimeError(
                 "Reasoning is required for this model, but no reasoning was returned."
             )
 
         # Generate the run and output
-        run = self.generate_run(input, input_source, parsed_output, usage)
+        run = self.generate_run(
+            input, input_source, parsed_output, usage, run_output.trace
+        )
 
         # Save the run if configured to do so, and we have a path to save to
         if (
             self.base_adapter_config.allow_saving
             and Config.shared().autosave_runs
-            and self.task().path is not None
+            and self.task.path is not None
         ):
             run.save_to_file()
         else:
@@ -257,6 +262,7 @@ class BaseAdapter(metaclass=ABCMeta):
         input_source: DataSource | None,
         run_output: RunOutput,
         usage: Usage | None = None,
+        trace: list[ChatCompletionMessageParam] | None = None,
     ) -> TaskRun:
         # Convert input and output to JSON strings if they are dictionaries
         input_str = (
@@ -276,7 +282,7 @@ class BaseAdapter(metaclass=ABCMeta):
             )
 
         new_task_run = TaskRun(
-            parent=self.task(),
+            parent=self.task,
             input=input_str,
             input_source=input_source,
             output=TaskOutput(
@@ -285,11 +291,13 @@ class BaseAdapter(metaclass=ABCMeta):
                 source=DataSource(
                     type=DataSourceType.synthetic,
                     properties=self._properties_for_task_output(),
+                    run_config=self.run_config,
                 ),
             ),
             intermediate_outputs=run_output.intermediate_outputs,
             tags=self.base_adapter_config.default_tags or [],
             usage=usage,
+            trace=trace,
         )
 
         return new_task_run
@@ -297,8 +305,10 @@ class BaseAdapter(metaclass=ABCMeta):
     def _properties_for_task_output(self) -> Dict[str, str | int | float]:
         props = {}
 
-        # adapter info
         props["adapter_name"] = self.adapter_name()
+
+        # Legacy properties where we save the run_config details into custom properties.
+        # These are now also be saved in the run_config field.
         props["model_name"] = self.run_config.model_name
         props["model_provider"] = self.run_config.model_provider_name
         props["prompt_id"] = self.run_config.prompt_id
@@ -321,3 +331,27 @@ class BaseAdapter(metaclass=ABCMeta):
             )
             new_run_config.structured_output_mode = structured_output_mode
             self.run_config = new_run_config
+
+    async def available_tools(self) -> list[KilnToolInterface]:
+        tool_config = self.run_config.tools_config
+        if tool_config is None or tool_config.tools is None:
+            return []
+
+        project = self.task.parent_project()
+        if project is None:
+            raise ValueError("Task must have a parent project to resolve tools")
+
+        project_id = project.id
+        if project_id is None:
+            raise ValueError("Project must have an ID to resolve tools")
+
+        tools = [tool_from_id(tool_id, self.task) for tool_id in tool_config.tools]
+
+        # Check each tool has a unique name
+        tool_names = [await tool.name() for tool in tools]
+        if len(tool_names) != len(set(tool_names)):
+            raise ValueError(
+                "Each tool must have a unique name. Either de-select the duplicate tools, or modify their names to describe their unique purpose. Model will struggle if tools do not have descriptive names and tool execution will be undefined."
+            )
+
+        return tools