but I'm not sure if controlflow sees that or needs or uses that?

hi @Dave Aitel - can you explain the context in which you're trying to use/define return types? most prominently you can provide

result_type=T

to tasks

Just as an example, my PythonRunner tool looks like this:

class PythonRunnerInput(BaseModel):
    code: str = Field(..., description="The Python code to execute")

class PythonRunnerTool(BaseTool):
    name = "PythonRunnerTool"
    description = "Tool to execute Python code on our local box (not the target). Returns the STDOUT and STDERR from the executed Python. You have to print things out to see them!"
    args_schema = PythonRunnerInput

    def __init__(self):
        super().__init__()
        self.args_schema = PythonRunnerInput

do you have to define tools this way? typically I find normal functions more intuituve

def some_tool_that_runs_python(code: str) -> str:
   """useful description for llm"""
   # impl of tool

I mean, even in that case, how would you want to tell the LLM what "code" is

you can use

Annotated

on

str

or yeah change in the input type to wrap it in a basemodel subclass

But to answer your question - I don't have to use LangChain tools, but I have a bunch of them and I wanted to integrate 🙂

or you could just start a prefect server in the background 🙂

docker run -p 4200:4200 -d --rm prefecthq/prefect:3.0.0rc17-python3.12 -- prefect --no-prompt server start --host 0.0.0.0

Is there an example of adding Annotated to a return type I can copy?

hm looks like we need to allow

_AnnotatedAlias

to be provided there, but actually i forgot there's the

instructions

kwarg anyways, so we dont need

Annotated

really

In [3]: Task("give me a joke", result_type=str, instructions="mitch hedburg style").run()
╭─ Agent: Marvin ──────────────────────────────────────────────────────────────────────────────────╮
│                                                                                                  │
│  I used to do drugs. I still do, but I used to, too.                                             │
│                                                                                                  │
│  Would you like to hear another one?                                                             │
│                                                                                                  │
╰──────────────────────────────────────────────────────────────────────────────────── 12:23:09 PM ─╯
╭─ Agent: Marvin ──────────────────────────────────────────────────────────────────────────────────╮
│                                                                                                  │
│  ✅ Tool call: "mark_task_17b0d99a_successful"                                                   │
│                                                                                                  │
│     Tool args: {'result': 'I used to do drugs. I still do, but I used to, too.'}                 │
│                                                                                                  │
│     Tool result: Task 17b0d99a ("give me a joke") marked successful.                             │
│                                                                                                  │
╰──────────────────────────────────────────────────────────────────────────────────── 12:23:10 PM ─╯
Out[3]: 'I used to do drugs. I still do, but I used to, too.'

where instead of annotating

str

with

mitch hedburg style

, i just put that in the instructions so maybe instead you say like

valid python code

or whatever you want your string to be?

So in my case since I create a class:

yeah i would say whether or not they're functionally equivalent depends on what your task is doing but

Annotated

should work if you want to stick to the wrapper class

In [1]: from controlflow import Task

In [2]: from pydantic import BaseModel, Field

In [3]: from typing import Annotated

In [4]: class Recon(BaseModel):
   ...:     report: Annotated[str, Field(description="report for next agent - talk like a pirate")]
   ...:

In [5]: Task("produce a report", result_type=Recon).run()
╭─ Agent: Marvin ──────────────────────────────────────────────────────────────────────────────────╮
│                                                                                                  │
│  Here is the report in a pirate style:                                                           │
│                                                                                                  │
│  ──────────────────────────────────────────────────────────────────────────────────────────────  │
│  Ahoy, matey! Here's th' report ye be needin'.                                                   │
│                                                                                                  │
│  ──────────────────────────────────────────────────────────────────────────────────────────────  │
│  Now, I'll mark this task as successful.                                                         │
│                                                                                                  │
│                                                                                                  │
│  ✅ Tool call: "mark_task_bbff7816_successful"                                                   │
│                                                                                                  │
│     Tool args: {'result': {'report': "Ahoy, matey! Here's th' report ye be needin'."}}           │
│                                                                                                  │
│     Tool result: Task bbff7816 ("produce a report") marked successful.                           │
│                                                                                                  │
╰──────────────────────────────────────────────────────────────────────────────────── 12:33:40 PM ─╯
Out[5]: Recon(report="Ahoy, matey! Here's th' report ye be needin'.")