unique_toolkit 1.76.0__tar.gz → 1.77.0__tar.gz

{unique_toolkit-1.76.0 → unique_toolkit-1.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.76.0
+Version: 1.77.0
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>

{unique_toolkit-1.76.0 → unique_toolkit-1.77.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "1.76.0"
+version = "1.77.0"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/__init__.py

@@ -0,0 +1,27 @@
+from unique_toolkit.agentic.tools.experimental.open_file_tool import (
+    OpenFileTool,
+    OpenFileToolRuntime,
+    OpenFileToolRuntimeConfig,
+)
+from unique_toolkit.agentic.tools.experimental.todo import (
+    TodoConfig,
+    TodoItem,
+    TodoItemInput,
+    TodoList,
+    TodoStatus,
+    TodoWriteInput,
+    TodoWriteTool,
+)
+
+__all__ = [
+    "OpenFileTool",
+    "OpenFileToolRuntime",
+    "OpenFileToolRuntimeConfig",
+    "TodoConfig",
+    "TodoItem",
+    "TodoItemInput",
+    "TodoList",
+    "TodoStatus",
+    "TodoWriteInput",
+    "TodoWriteTool",
+]

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/__init__.py

@@ -0,0 +1,24 @@
+from unique_toolkit.agentic.tools.experimental.todo.config import TodoConfig
+from unique_toolkit.agentic.tools.experimental.todo.schemas import (
+    TodoItem,
+    TodoItemInput,
+    TodoList,
+    TodoStatus,
+    TodoWriteInput,
+)
+from unique_toolkit.agentic.tools.experimental.todo.service import (
+    TodoWriteTool,
+)
+from unique_toolkit.agentic.tools.factory import ToolFactory
+
+ToolFactory.register_tool(TodoWriteTool, TodoConfig)
+
+__all__ = [
+    "TodoConfig",
+    "TodoItem",
+    "TodoItemInput",
+    "TodoList",
+    "TodoStatus",
+    "TodoWriteInput",
+    "TodoWriteTool",
+]

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/config.py

@@ -0,0 +1,94 @@
+from typing import Annotated
+
+from pydantic import Field
+
+from unique_toolkit._common.pydantic.rjsf_tags import RJSFMetaTag
+from unique_toolkit.agentic.tools.experimental.todo.prompts import (
+    EXECUTION_REMINDER_TEMPLATE,
+    SYSTEM_PROMPT_TEMPLATE,
+    TOOL_DESCRIPTION_TEMPLATE,
+    VERIFICATION_NUDGE_TEMPLATE,
+)
+from unique_toolkit.agentic.tools.schemas import BaseToolConfig
+
+
+class TodoConfig(BaseToolConfig):
+    display_name: str = Field(
+        default="Progress",
+        description="Human-readable label for task tracking shown in the Steps panel.",
+    )
+
+    tool_description: Annotated[
+        str,
+        RJSFMetaTag.StringWidget.textarea(rows=3),
+    ] = Field(
+        default=TOOL_DESCRIPTION_TEMPLATE,
+        description="Edit this Jinja template to customize the tool description passed to the LLM."
+        "Available variable: parallel_mode (bool).",
+    )
+
+    system_prompt: Annotated[
+        str,
+        RJSFMetaTag.StringWidget.textarea(rows=15),
+    ] = Field(
+        default=SYSTEM_PROMPT_TEMPLATE,
+        description="Edit this Jinja template to customize the system prompt injected for task tracking. "
+        "Available variable: parallel_mode (bool).",
+    )
+
+    execution_reminder: Annotated[
+        str,
+        RJSFMetaTag.StringWidget.textarea(rows=5),
+    ] = Field(
+        default=EXECUTION_REMINDER_TEMPLATE,
+        description="Edit this Jinja template to customize the reminder appended to tool responses "
+        "during execution phase. Available variable: parallel_mode (bool).",
+    )
+
+    parallel_mode: Annotated[
+        bool,
+        RJSFMetaTag.BooleanWidget.checkbox(
+            help=(
+                "When enabled, the agent may combine task tracking with other "
+                "tool calls in the same turn and mark multiple items "
+                "in_progress simultaneously. When disabled (default), the "
+                "agent works through items one at a time with sequential "
+                "status updates."
+            ),
+        ),
+    ] = Field(
+        default=False,
+        title="Track tasks alongside other tool calls",
+        description="Parallel Mode for Task Tracking",
+    )
+
+    show_triggered_tool_calls: Annotated[
+        bool,
+        RJSFMetaTag.BooleanWidget.checkbox(
+            help=(
+                "Show 'Triggered Tool Calls' entries in the Steps panel "
+                "listing which tools the agent called each iteration. "
+            ),
+        ),
+    ] = Field(
+        default=True,
+        title="Display triggered tool calls in the Steps panel",
+        description="Display Triggered Tool Calls",
+    )
+
+    verification_threshold: int = Field(
+        default=5,
+        ge=0,
+        title="Verification Nudge Threshold",
+        description="After this many task completions, nudge the agent to verify its work "
+        "before continuing. Set to 0 to disable.",
+    )
+
+    verification_nudge: Annotated[
+        str,
+        RJSFMetaTag.StringWidget.textarea(rows=2),
+    ] = Field(
+        default=VERIFICATION_NUDGE_TEMPLATE,
+        description="Jinja template for the verification nudge message. "
+        "Available variable: completed (int).",
+    )

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/prompts/__init__.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+_PROMPTS_DIR = Path(__file__).parent
+
+
+def _load(name: str) -> str:
+    return (_PROMPTS_DIR / name).read_text().strip()
+
+
+TOOL_DESCRIPTION_TEMPLATE = _load("tool_description.j2")
+SYSTEM_PROMPT_TEMPLATE = _load("system_prompt.j2")
+EXECUTION_REMINDER_TEMPLATE = _load("execution_reminder.j2")
+VERIFICATION_NUDGE_TEMPLATE = _load("verification_nudge.j2")

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/prompts/execution_reminder.j2

@@ -0,0 +1,11 @@
+You are in the EXECUTION PHASE.
+Do NOT ask the user any questions or request confirmation.
+You MUST process every pending item — do not skip or summarize.
+{%- if parallel_mode %}
+- Always include a TodoWrite call alongside your work tool calls in the same response — mark items in_progress before executing and completed after.
+- Do not use a separate turn just for status updates.
+{%- else %}
+- Mark exactly one item in_progress, complete it, then move to the next.
+- Do not batch completions.
+{%- endif %}
+- Do NOT write a final text response while items are still pending or in_progress — keep executing until every item reaches a terminal state (completed/cancelled), then call TodoWrite one final time before responding.

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/prompts/system_prompt.j2

@@ -0,0 +1,41 @@
+You have access to a task tracking tool (TodoWrite). Use it proactively — the user sees the task list as a live progress indicator.
+
+## When to Use
+
+Use for any task with 3+ steps, batch operations, or when the user gives a numbered list. For batch operations (e.g. "process all invoices"), create one task per item so none are skipped. When receiving new instructions mid-conversation, immediately capture them as tasks. Skip for single-step lookups or simple factual questions.
+
+Examples:
+- "Research competitor pricing and write a comparison" → create tasks per competitor + comparison + summary
+- "Process all invoices in uploads" → one task per invoice
+- "What's the capital of France?" → do NOT use TodoWrite
+
+## Workflow
+
+1. CLARIFICATION PHASE: Ask ALL clarifying questions in a single message upfront.
+2. EXECUTION PHASE: After creating the task list, execute every step autonomously. Do NOT ask follow-up questions — use sensible defaults and document your assumptions.
+
+## Task Design
+
+- Break into 3-7 specific, actionable items with clear outcomes
+- Provide active_form for each (e.g. content: "Search pricing data", active_form: "Searching pricing data")
+- For complex tasks, include a final "verify and synthesize" item
+
+## Execution Rules
+
+- Execute immediately after creating the list. Do NOT ask for confirmation between steps.
+{% if parallel_mode -%}
+- Mark multiple items in_progress simultaneously. Combine TodoWrite with work tool calls in the same response — do not waste a turn on bookkeeping alone.
+{%- else -%}
+- Mark exactly ONE item in_progress at a time. Complete and mark it immediately before starting the next — do not batch completions.
+{%- endif %}
+- After completing a task, check if follow-up tasks need to be added.
+- When unclear, if there is a reasonable default, choose it rather than stopping to ask. Document your assumption.
+- Do NOT summarize remaining items or ask if you should continue. Just keep going.
+- The ONLY reason to stop is a hard blocker: missing credentials, nonexistent resource, or unrecoverable error.
+
+## Completion
+
+- Never write a final response while items are still pending — if items remain, keep executing.
+- You MUST call TodoWrite to mark every item completed/cancelled before your final response. Zero pending/in_progress items must remain.
+- You have a limited iteration budget. Mark all items terminal BEFORE the final iteration when tools are removed.
+- Items needing only analysis (no tool call) should be marked completed as soon as you have the data.

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/prompts/tool_description.j2

@@ -0,0 +1,9 @@
+Create or update a task list to track progress. Use for any task involving multiple steps — the user sees this as a live progress indicator.
+
+Provide active_form (present continuous, e.g. "Searching documents") for each task — this is shown to the user as live status text.
+
+{% if parallel_mode -%}
+Mark items in_progress when starting, completed when done. You can mark multiple items in_progress if working on them in parallel.
+{%- else -%}
+Mark exactly one item in_progress at a time. Mark it completed immediately when done, then move to the next item. Do not batch completions.
+{%- endif %}

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/prompts/verification_nudge.j2

@@ -0,0 +1 @@
+[Checkpoint: {{ completed }} tasks completed. Before continuing, briefly verify recent results are correct.]

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/schemas.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections import Counter
+from enum import StrEnum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class TodoStatus(StrEnum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    CANCELLED = "cancelled"
+
+
+_STATUS_ICONS: dict[TodoStatus, str] = {
+    TodoStatus.PENDING: "[ ]",
+    TodoStatus.IN_PROGRESS: "[>]",
+    TodoStatus.COMPLETED: "[x]",
+    TodoStatus.CANCELLED: "[-]",
+}
+
+_TERMINAL_STATUSES: frozenset[TodoStatus] = frozenset(
+    {TodoStatus.COMPLETED, TodoStatus.CANCELLED}
+)
+
+
+model_config = ConfigDict(extra="forbid")
+
+
+class TodoItem(BaseModel):
+    """Stored todo item — always has content."""
+
+    model_config = model_config
+
+    id: str = Field(
+        description="Unique identifier for this TODO (model-generated, free-form string e.g. 'research-apis', 'step-1')",
+    )
+    content: str = Field(description="Description of the task")
+    status: TodoStatus
+    active_form: str | None = Field(
+        description="Present-continuous form of the task shown as live status text "
+        "(e.g. 'Searching documents', 'Analyzing results'). "
+        "Provide when creating or updating an item.",
+    )
+
+
+class TodoItemInput(BaseModel):
+    """Input todo item — content is optional for merge updates (status-only changes)."""
+
+    model_config = model_config
+    id: str = Field(
+        description="Unique identifier for this TODO (model-generated, free-form string e.g. 'research-apis', 'step-1')",
+    )
+    content: str | None = Field(
+        description="Description of the task. Required when creating new items, optional when updating existing ones via merge.",
+    )
+    status: TodoStatus
+    active_form: str | None = Field(
+        description="Present-continuous form shown as live status text "
+        "(e.g. 'Searching documents'). Provide for richer UI display.",
+    )
+
+
+class TodoList(BaseModel):
+    """Full TODO state for a session. Stored in ShortTermMemory."""
+
+    model_config = model_config
+    todos: list[TodoItem] = Field(description="The list of todo items.")
+    last_updated_iteration: int = Field(
+        description="The iteration number of the last update."
+    )
+
+    def update(self, incoming: list[TodoItemInput]) -> TodoList:
+        """Update by ID: overwrite existing, append new, preserve unmentioned.
+
+        When an incoming item omits content, the existing content is preserved.
+        active_form falls back to existing value when not supplied.
+        New items without content get an empty string as fallback.
+        """
+        existing_by_id = {t.id: t for t in self.todos}
+        for item in incoming:
+            existing = existing_by_id.get(item.id)
+            content = (
+                item.content
+                if item.content is not None
+                else (existing.content if existing else "")
+            )
+            active_form = (
+                item.active_form
+                if item.active_form is not None
+                else (existing.active_form if existing else None)
+            )
+            existing_by_id[item.id] = TodoItem(
+                id=item.id,
+                content=content,
+                status=item.status,
+                active_form=active_form,
+            )
+        return TodoList(
+            todos=list(existing_by_id.values()),
+            last_updated_iteration=self.last_updated_iteration,
+        )
+
+    def has_active_items(self) -> bool:
+        return any(t.status not in _TERMINAL_STATUSES for t in self.todos)
+
+    def format(self) -> str:
+        """Format as human-readable text for tool responses."""
+        if not self.todos:
+            return "No tasks tracked."
+        summary = self._summarize()
+        return f"Task list ({summary}):\n" + "\n".join(self._format_lines())
+
+    def status_counter(self) -> Counter[str]:
+        """Return a Counter of status values. Missing keys auto-return 0."""
+        return Counter(t.status.value for t in self.todos)
+
+    def _format_lines(self) -> list[str]:
+        return [
+            f"  {_STATUS_ICONS.get(t.status, '[ ]')} {t.content} (id: {t.id})"
+            for t in self.todos
+        ]
+
+    def _summarize(self) -> str:
+        completed = sum(1 for t in self.todos if t.status == TodoStatus.COMPLETED)
+        return f"{completed}/{len(self.todos)} completed"
+
+
+class TodoWriteInput(BaseModel):
+    model_config = model_config
+    todos: list[TodoItemInput] = Field(
+        min_length=1, description="The list of todo items to update."
+    )
+    merge: bool = Field(
+        description="If true, merge with existing todos by ID. If false, replace entirely.",
+    )

unique_toolkit-1.77.0/unique_toolkit/agentic/tools/experimental/todo/service.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+from collections import Counter
+from logging import getLogger
+
+from unique_toolkit._common.utils.jinja.render import render_template
+from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
+from unique_toolkit.agentic.short_term_memory_manager.persistent_short_term_memory_manager import (
+    PersistentShortMemoryManager,
+)
+from unique_toolkit.agentic.tools.experimental.todo.config import TodoConfig
+from unique_toolkit.agentic.tools.experimental.todo.schemas import (
+    TodoItem,
+    TodoList,
+    TodoStatus,
+    TodoWriteInput,
+)
+from unique_toolkit.agentic.tools.schemas import ToolCallResponse
+from unique_toolkit.agentic.tools.tool import Tool
+from unique_toolkit.agentic.tools.tool_progress_reporter import ToolProgressReporter
+from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.chat.schemas import MessageLog, MessageLogStatus
+from unique_toolkit.language_model import LanguageModelToolDescription
+from unique_toolkit.language_model.schemas import LanguageModelFunction
+from unique_toolkit.short_term_memory.service import ShortTermMemoryService
+
+logger = getLogger(__name__)
+
+
+MEMORY_KEY = "agent_todo_state"
+
+_STATUS_ICON = {
+    TodoStatus.COMPLETED: "✓",
+    TodoStatus.IN_PROGRESS: "→",
+    TodoStatus.CANCELLED: "✗",
+    TodoStatus.PENDING: "○",
+}
+
+
+class TodoWriteTool(Tool[TodoConfig]):
+    name: str = "TodoWrite"
+
+    def __init__(
+        self,
+        config: TodoConfig,
+        event: ChatEvent,
+        tool_progress_reporter: ToolProgressReporter | None = None,
+    ) -> None:
+        super().__init__(config, event, tool_progress_reporter)
+        stm_service = ShortTermMemoryService(
+            company_id=event.company_id,
+            user_id=event.user_id,
+            chat_id=event.payload.chat_id,
+            message_id=None,
+        )
+        self._memory_manager: PersistentShortMemoryManager[TodoList] = (
+            PersistentShortMemoryManager(
+                short_term_memory_service=stm_service,
+                short_term_memory_schema=TodoList,
+                short_term_memory_name=MEMORY_KEY,
+            )
+        )
+        self._cached_state: TodoList | None = None
+        self._plan_log: MessageLog | None = None
+
+    def display_name(self) -> str:
+        return self.config.display_name
+
+    def tool_description(self) -> LanguageModelToolDescription:
+        return LanguageModelToolDescription(
+            name=self.name,
+            description=render_template(
+                self.config.tool_description,
+                parallel_mode=self.config.parallel_mode,
+            ),
+            parameters=TodoWriteInput.model_json_schema(),
+        )
+
+    def tool_description_for_system_prompt(self) -> str:
+        return render_template(
+            self.config.system_prompt,
+            parallel_mode=self.config.parallel_mode,
+        )
+
+    async def run(self, tool_call: LanguageModelFunction) -> ToolCallResponse:
+        try:
+            input_data = TodoWriteInput.model_validate(tool_call.arguments)
+        except Exception as e:
+            logger.warning("TodoWriteTool: input validation failed: %s", e)
+            return ToolCallResponse(
+                id=tool_call.id,
+                name=self.name,
+                content=f"Error: invalid input — {e}. "
+                "When using merge=True, each item needs at least 'id' and 'status'. "
+                "When using merge=False (new list), each item also needs 'content'.",
+            )
+
+        logger.debug(
+            "TodoWriteTool input: merge=%s, items=%s",
+            input_data.merge,
+            [
+                {"id": t.id, "content": t.content, "status": t.status}
+                for t in input_data.todos
+            ],
+        )
+
+        current_state = await self._load_state()
+
+        if input_data.merge:
+            current_state = current_state.update(input_data.todos)
+        else:
+            current_state = TodoList(
+                todos=[
+                    TodoItem(
+                        id=t.id,
+                        content=t.content or "",
+                        status=t.status,
+                        active_form=t.active_form,
+                    )
+                    for t in input_data.todos
+                ],
+                last_updated_iteration=current_state.last_updated_iteration,
+            )
+
+        current_state.last_updated_iteration += 1
+        self._cached_state = current_state
+
+        try:
+            await self._memory_manager.save_async(current_state)
+        except Exception:
+            logger.warning(
+                "TodoWriteTool: failed to persist state, continuing with in-memory state",
+                exc_info=True,
+            )
+
+        logger.info(
+            "TodoWriteTool: saved %d items (merge=%s) — %s",
+            len(current_state.todos),
+            input_data.merge,
+            current_state.format(),
+        )
+
+        counts = current_state.status_counter()
+        await self._log_step(current_state)
+
+        content = current_state.format()
+        content = self._maybe_add_verification_nudge(content, counts)
+
+        return ToolCallResponse(
+            id=tool_call.id,
+            name=self.name,
+            content=content,
+            system_reminder=render_template(
+                self.config.execution_reminder,
+                parallel_mode=self.config.parallel_mode,
+            )
+            if current_state.has_active_items()
+            else "",
+            debug_info={
+                "input": {
+                    "merge": input_data.merge,
+                    "items": [t.model_dump() for t in input_data.todos],
+                },
+                "state": {
+                    **counts,
+                    "items": [t.model_dump() for t in current_state.todos],
+                },
+                "iteration": current_state.last_updated_iteration,
+            },
+        )
+
+    async def _log_step(self, state: TodoList) -> None:
+        """Write a single Steps panel entry summarising the current todo state.
+
+        Shows a numbered list of all items with status indicators (✓/→/○)
+        and a completion count header. In-progress items display their
+        ``active_form`` (present-continuous description) when available.
+        """
+        try:
+            counts = state.status_counter()
+            completed = counts["completed"]
+            total = len(state.todos)
+
+            if total == 0:
+                return
+
+            all_done = not counts["in_progress"] and not counts["pending"]
+
+            lines = []
+            for i, t in enumerate(state.todos, 1):
+                icon = _STATUS_ICON.get(t.status, "○")
+                if t.status == TodoStatus.IN_PROGRESS:
+                    label = t.active_form or t.content
+                else:
+                    label = t.content
+                lines.append(f"{icon} {i}. {label}")
+            plan_text = "\n".join(lines)
+
+            self._plan_log = (
+                await self._message_step_logger.create_or_update_message_log_async(
+                    active_message_log=self._plan_log,
+                    header=self.display_name(),
+                    progress_message=f"{completed}/{total} completed\n{plan_text}",
+                    status=(
+                        MessageLogStatus.COMPLETED
+                        if all_done
+                        else MessageLogStatus.RUNNING
+                    ),
+                )
+            )
+        except Exception:
+            logger.debug("TodoWriteTool: failed to write step log", exc_info=True)
+
+    def _maybe_add_verification_nudge(self, content: str, counts: Counter[str]) -> str:
+        """Append a verification nudge after N consecutive completions."""
+        threshold = self.config.verification_threshold
+        if threshold <= 0:
+            return content
+        completed = counts["completed"]
+        if completed > 0 and completed % threshold == 0 and counts["pending"]:
+            nudge = render_template(self.config.verification_nudge, completed=completed)
+            content += f"\n\n{nudge}"
+        return content
+
+    async def _load_state(self) -> TodoList:
+        """Load state from persistence, falling back to in-memory cache.
+
+        When both persisted and cached state exist, prefer whichever has the
+        higher ``last_updated_iteration`` — the cache may be ahead if a
+        previous ``save_async`` failed.
+        """
+        persisted: TodoList | None = None
+        try:
+            persisted = await self._memory_manager.load_async()
+        except Exception:
+            logger.warning(
+                "TodoWriteTool: failed to load persisted state",
+                exc_info=True,
+            )
+
+        if persisted is not None and self._cached_state is not None:
+            if (
+                self._cached_state.last_updated_iteration
+                > persisted.last_updated_iteration
+            ):
+                logger.info(
+                    "TodoWriteTool: cache (iter %d) is ahead of persisted (iter %d), keeping cache",
+                    self._cached_state.last_updated_iteration,
+                    persisted.last_updated_iteration,
+                )
+                return self._cached_state
+            self._cached_state = persisted
+            return persisted
+
+        if persisted is not None:
+            self._cached_state = persisted
+            return persisted
+
+        if self._cached_state is not None:
+            logger.debug("TodoWriteTool: using in-memory cached state")
+            return self._cached_state
+
+        return TodoList(todos=[], last_updated_iteration=0)
+
+    def evaluation_check_list(self) -> list[EvaluationMetricName]:
+        return []
+
+    def get_evaluation_checks_based_on_tool_response(
+        self, tool_response: ToolCallResponse
+    ) -> list[EvaluationMetricName]:
+        return []

unique_toolkit-1.76.0/unique_toolkit/agentic/tools/experimental/__init__.py

@@ -1,11 +0,0 @@
-from unique_toolkit.agentic.tools.experimental.open_file_tool import (
-    OpenFileTool,
-    OpenFileToolRuntime,
-    OpenFileToolRuntimeConfig,
-)
-
-__all__ = [
-    "OpenFileTool",
-    "OpenFileToolRuntime",
-    "OpenFileToolRuntimeConfig",
-]