add dummy tools

Author: eb8680

effectful/handlers/llm/completions.py

@@ -260,15 +260,19 @@ def call_assistant[T, U](
             includes the raw assistant message for retry handling.
     """
     tool_specs = {k: _function_model(t) for k, t in tools.items()}
-    response_model = pydantic.create_model(
-        "Response", value=response_format.enc, __config__={"extra": "forbid"}
+    response_model = (
+        response_format.enc
+        if issubclass(response_format.enc, pydantic.BaseModel)
+        else pydantic.create_model(
+            "Response", value=response_format.enc, __config__={"extra": "forbid"}
+        )
     )
 
     messages = list(get_message_sequence().values())
     response: litellm.types.utils.ModelResponse = completion(
         model,
         messages=list(messages),
-        response_format=response_model,
+        response_format=response_model if response_format.enc is not str else None,
         tools=list(tool_specs.values()),
         **kwargs,
     )
@@ -291,17 +295,26 @@ def call_assistant[T, U](
         tool_calls.append(decoded_tool_call)
 
     result = None
-    if not tool_calls:
+    if not tool_calls and response_format.enc is not str:
         # return response
         serialized_result = message.get("content") or message.get("reasoning_content")
         assert isinstance(serialized_result, str), (
             "final response from the model should be a string"
         )
         try:
             raw_result = response_model.model_validate_json(serialized_result)
-            result = response_format.decode(raw_result.value)  # type: ignore
+            result = response_format.decode(
+                raw_result.value
+                if not issubclass(response_format.enc, pydantic.BaseModel)
+                else raw_result
+            )  # type: ignore
         except (pydantic.ValidationError, TypeError, ValueError, SyntaxError) as e:
             raise ResultDecodingError(e, raw_message=raw_message) from e
+    elif not tool_calls and response_format.enc is str:
+        # if expecting a string result, return the raw content as the result
+        content = message.get("content") or message.get("reasoning_content")
+        assert isinstance(content, str), "Expected content to be a string"
+        result = content
 
     return (raw_message, tool_calls, result)
 
@@ -387,7 +400,36 @@ def flush_text() -> None:
 @Operation.define
 def call_system(template: Template) -> collections.abc.Sequence[Message]:
     """Get system instruction message(s) to prepend to all LLM prompts."""
-    return ()
+
+    assert inspect.getdoc(type(template)) is not None
+
+    system_prompt = inspect.cleandoc(f"""
+    You are responsible for implementing the `Template` '{template.__name__}' defined in the module source code below.
+
+    First, as background, here is the class-level documentation for the `Template` class::
+
+    {inspect.getdoc(type(template))}
+    """)
+
+    try:
+        system_prompt += inspect.cleandoc(f"""
+        Here is the source code of the module defining the `Template` instance '{template.__name__}'::
+
+        {inspect.getsource(inspect.getmodule(template))}
+        """)
+    except (TypeError, OSError):
+        system_prompt += inspect.cleandoc(f"""
+        The source code for the module defining '{template.__name__}' is not available.
+        Instead, here are the signature and docstring of '{template.__name__}'::
+
+        {template.__name__} :: {template.__signature__.format()}
+
+        {inspect.cleandoc(template.__prompt_template__)}
+        """)
+
+    msg = _make_message(dict(role="system", content=system_prompt))
+    append_message(msg)
+    return (msg,)
 
 
 class RetryLLMHandler(ObjectInterpretation):

effectful/handlers/llm/template.py

@@ -110,6 +110,20 @@ class _BoundInstance[T]:
     instance: T
 
 
+def _make_context_tool[T](name: str, value: T) -> Tool[[], T]:
+    """Create a synthetic read-only Tool for a lexical variable."""
+    from effectful.internals.unification import nested_type
+
+    def reader():
+        return value
+
+    reader.__name__ = name
+    reader.__doc__ = f"Read the value of lexical variable `{name}`"
+    reader.__annotations__ = {"return": nested_type(value).value}
+
+    return Tool.define(reader)
+
+
 class Template[**P, T](Tool[P, T]):
     """A :class:`Template` is a function that is implemented by a large language model.
 
@@ -187,21 +201,33 @@ def tools(self) -> Mapping[str, Tool]:
                 continue
 
             # Collect tools in context
-            if isinstance(obj, Tool):
+            elif isinstance(obj, Tool):
                 result[name] = obj
 
-            if isinstance(obj, staticmethod) and isinstance(obj.__func__, Tool):
+            elif isinstance(obj, staticmethod) and isinstance(obj.__func__, Tool):
                 result[name] = obj.__func__
 
             # Collect tools as methods on any bound instances
-            if isinstance(obj, _BoundInstance):
+            elif isinstance(obj, _BoundInstance):
                 for instance_name in obj.instance.__dir__():
                     if instance_name.startswith(INSTANCE_OP_PREFIX):
                         continue
                     instance_obj = getattr(obj.instance, instance_name)
                     if isinstance(instance_obj, Tool):
                         result[instance_name] = instance_obj
 
+            # Make tools for lexical variables
+            elif not (
+                name.startswith("__")
+                or isinstance(obj, Operation)
+                or inspect.isclass(obj)
+                or inspect.isbuiltin(obj)
+                or inspect.ismodule(obj)
+                or inspect.isroutine(obj)
+                or inspect.isabstract(obj)
+            ):
+                result[name] = _make_context_tool(name, obj)
+
         return result
 
     def __get__[S](self, instance: S | None, owner: type[S] | None = None):