Your own tool

1# tests/test_tools.py
2
3from datetime import date
4
5import pytest
6
7from contract_crew.tools import add_months, next_notice_deadline
8
9
10@pytest.mark.parametrize(
11    "start, months, expected",
12    [
13        (date(2026, 3, 1), 12, date(2027, 3, 1)),
14        (date(2026, 1, 31), 1, date(2026, 2, 28)),
15        (date(2027, 11, 30), 3, date(2028, 2, 29)),
16    ],
17)
18def test_add_months(start, months, expected):
19    assert add_months(start, months) == expected
20
21
22def test_deadline_is_notice_days_before_the_term_ends():
23    term_end, deadline = next_notice_deadline(
24        effective_date=date(2026, 3, 1),
25        initial_term_months=12,
26        renewal_term_months=12,
27        notice_days=60,
28        today=date(2026, 10, 19),
29    )
30    assert term_end == date(2027, 2, 28)
31    assert deadline == date(2026, 12, 30)
32
33
34def test_deadline_on_the_last_day_still_counts():
35    _, deadline = next_notice_deadline(
36        effective_date=date(2026, 3, 1),
37        initial_term_months=12,
38        renewal_term_months=12,
39        notice_days=60,
40        today=date(2026, 12, 30),
41    )
42    assert deadline == date(2026, 12, 30)
43
44
45def test_missed_deadline_rolls_over_to_the_next_term():
46    term_end, deadline = next_notice_deadline(
47        effective_date=date(2026, 3, 1),
48        initial_term_months=12,
49        renewal_term_months=12,
50        notice_days=60,
51        today=date(2026, 12, 31),
52    )
53    assert term_end == date(2028, 2, 29)
54    assert deadline == date(2027, 12, 31)

1(env)$ python -m pytest

1# contract_crew/tools.py
2
3import calendar
4from datetime import date, timedelta
5
6
7def add_months(day, months):
8    month_index = day.month - 1 + months
9    year = day.year + month_index // 12
10    month = month_index % 12 + 1
11    last_day = calendar.monthrange(year, month)[1]
12    return date(year, month, min(day.day, last_day))
13
14
15def next_notice_deadline(effective_date, initial_term_months, renewal_term_months, notice_days, today):
16    term_end = add_months(effective_date, initial_term_months) - timedelta(days=1)
17    while term_end - timedelta(days=notice_days) < today:
18        term_start = term_end + timedelta(days=1)
19        term_end = add_months(term_start, renewal_term_months) - timedelta(days=1)
20    return term_end, term_end - timedelta(days=notice_days)

1(env)$ python -m pytest
2
3tests/test_crew.py .                                                     [ 14%]
4tests/test_tools.py ......                                               [100%]
5
6======================== 7 passed, 11 warnings in 3.00s ========================

1# contract_crew/tools.py
2
3import calendar
4from datetime import date, timedelta
5
6from crewai.tools import BaseTool
7from pydantic import BaseModel, Field
8
9
10def add_months(day, months):
11    month_index = day.month - 1 + months
12    year = day.year + month_index // 12
13    month = month_index % 12 + 1
14    last_day = calendar.monthrange(year, month)[1]
15    return date(year, month, min(day.day, last_day))
16
17
18def next_notice_deadline(effective_date, initial_term_months, renewal_term_months, notice_days, today):
19    term_end = add_months(effective_date, initial_term_months) - timedelta(days=1)
20    while term_end - timedelta(days=notice_days) < today:
21        term_start = term_end + timedelta(days=1)
22        term_end = add_months(term_start, renewal_term_months) - timedelta(days=1)
23    return term_end, term_end - timedelta(days=notice_days)
24
25
26class NoticeDeadlineInput(BaseModel):
27    effective_date: date = Field(description="The date the agreement started, as YYYY-MM-DD")
28    initial_term_months: int = Field(description="Length of the initial term, in months")
29    renewal_term_months: int = Field(description="Length of each renewal term, in months")
30    notice_days: int = Field(description="Days of notice needed before a term ends to stop it renewing")
31
32
33class NoticeDeadlineTool(BaseTool):
34    name: str = "notice_deadline_calculator"
35    description: str = (
36        "Works out when the current contract term ends and the last day to send "
37        "a notice of non-renewal. Use it for any renewal or notice date instead "
38        "of calculating dates yourself."
39    )
40    args_schema: type[BaseModel] = NoticeDeadlineInput
41
42    def _run(self, effective_date, initial_term_months, renewal_term_months, notice_days):
43        today = date.today()
44        term_end, deadline = next_notice_deadline(
45            effective_date=date.fromisoformat(str(effective_date)),
46            initial_term_months=int(initial_term_months),
47            renewal_term_months=int(renewal_term_months),
48            notice_days=int(notice_days),
49            today=today,
50        )
51        days_left = (deadline - today).days
52        return (
53            f"The next term that can still be stopped ends on {term_end.isoformat()}. "
54            f"Notice of non-renewal must be sent by {deadline.isoformat()}, "
55            f"which is {days_left} days from today ({today.isoformat()})."
56        )

1(env)$ python -c '
2from contract_crew.tools import NoticeDeadlineTool
3print(NoticeDeadlineTool().run(effective_date="2026-03-01", initial_term_months=12, renewal_term_months=12, notice_days=60))
4'

1# contract_crew/crew.py
2
3from crewai import Agent, Crew, Process, Task
4from crewai.project import CrewBase, agent, crew, task
5from crewai_tools import FileReadTool
6
7from contract_crew.models import ContractTerms
8from contract_crew.tools import NoticeDeadlineTool
9
10
11@CrewBase
12class ContractReviewCrew:
13    """Reads a contract, flags the risks, and checks the memo against the source."""
14
15    agents_config = "config/agents.yaml"
16    tasks_config = "config/tasks.yaml"
17
18    def __init__(self):
19        self.read_file = FileReadTool()
20        self.notice_deadline = NoticeDeadlineTool()
21
22    @agent
23    def reader(self) -> Agent:
24        return Agent(config=self.agents_config["reader"], tools=[self.read_file], verbose=True)
25
26    @agent
27    def risk_analyst(self) -> Agent:
28        return Agent(config=self.agents_config["risk_analyst"], tools=[self.notice_deadline], verbose=True)
29
30    @agent
31    def fact_checker(self) -> Agent:
32        return Agent(
33            config=self.agents_config["fact_checker"],
34            tools=[self.read_file, self.notice_deadline],
35            verbose=True,
36        )
37
38    @task
39    def extract_terms(self) -> Task:
40        return Task(config=self.tasks_config["extract_terms"], output_pydantic=ContractTerms)
41
42    @task
43    def assess_risks(self) -> Task:
44        return Task(config=self.tasks_config["assess_risks"])
45
46    @task
47    def fact_check(self) -> Task:
48        return Task(config=self.tasks_config["fact_check"])
49
50    @crew
51    def crew(self) -> Crew:
52        return Crew(
53            agents=self.agents,
54            tasks=self.tasks,
55            process=Process.sequential,
56            verbose=True,
57        )

1assess_risks:
2  description: >
3    Using the key terms, write a risk memo for {customer}. Pick the five terms
4    most likely to cost them money or catch them out, and say what they
5    should do about each one. For any renewal or notice date, use the notice
6    deadline calculator instead of working out dates yourself. The memo is
7    for the finance team, so don't mention your tools in it.
8  expected_output: >
9    A Markdown memo of no more than 350 words: a two-sentence summary, then a
10    numbered list of five risks. Each risk has a section number, why it
11    matters, and a recommended action. Give the exact date for every
12    deadline.
13  agent: risk_analyst
14
15fact_check:
16  description: >
17    Check every claim in the risk memo against the contract at {contract_path}.
18    Fix any number, date, or section reference that does not match the
19    contract, and remove anything the contract does not say. Check renewal
20    and notice dates with the notice deadline calculator, and don't mention
21    your tools in the memo.
22  expected_output: >
23    The corrected memo in Markdown, followed by a "Corrections" section that
24    lists each change you made, or says "None".
25  agent: fact_checker
26  output_file: output/review.md

1(env)$ python main.py

Tool notice_deadline_calculator executed with result: The next term that can still bestopped ends on 2027-02-28. Notice of non-renewal must be sent by 2026-12-30, which is 72days from today (2026-10-19).

### 1. Auto-Renewal Without Clear Exit StrategyRisk: The agreement auto-renews for 12-month terms unless Northwind provides 60 days'written notice before each renewal. The last day to send notice for the first renewal isDecember 30, 2026. ...
### Corrections1. Auto-Renewal Deadline: Updated the last day to send notice for the first renewal from   August 31, 2026, to December 30, 2026 (calculated using the correct renewal term end   date).

contract-crew├── .env├── .gitignore├── contract_crew│   ├── __init__.py│   ├── config│   │   ├── agents.yaml│   │   └── tasks.yaml│   ├── crew.py│   ├── models.py│   └── tools.py├── contracts│   └── acme-saas-agreement.md├── explain.py├── main.py├── output│   └── review.md├── summarize.py└── tests    ├── __init__.py    ├── test_crew.py    └── test_tools.py