deeptutor-solve 1.7.0__py3-none-any.whl

deeptutor/capabilities/solve/__init__.py

@@ -0,0 +1,6 @@
+"""Deep Solve loop capability."""
+
+from deeptutor.capabilities.solve.loop import SolveLoopCapability
+from deeptutor.capabilities.solve.tools import SOLVE_TOOL_NAMES, SOLVE_TOOL_TYPES
+
+__all__ = ["SOLVE_TOOL_NAMES", "SOLVE_TOOL_TYPES", "SolveLoopCapability"]

deeptutor/capabilities/solve/capability.py

@@ -0,0 +1,87 @@
+"""Deep Solve capability — problem solving driven by the chat agent loop.
+
+There is no bespoke pipeline anymore. The chat agent loop IS the solver: this
+capability marks the turn as solve mode and resolves a session id, then runs
+the standard agentic chat pipeline. The solve loop capability
+(:class:`deeptutor.capabilities.solve.loop.SolveLoopCapability`) mounts the
+solve tools (``solve_plan`` / ``solve_finish_step`` / ``solve_replan``) plus a
+curated built-in toolset
+(``rag`` / unified ``exec`` / ``geogebra_analysis`` / …) and injects the
+solver playbook; the in-memory :class:`SolveSession` holds the plan, the
+per-step gate, and the replan budget.
+
+Design axiom (shared with chat / mastery): the intelligence lives at the
+loop's exit — the model plans and solves — while the deterministic spine
+(commit to a plan, don't skip steps, bounded replan) is engine state read and
+written through tools.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import cast
+
+from deeptutor.agents.chat.agentic_pipeline import AgenticChatPipeline
+from deeptutor.capabilities.solve.session import DEFAULT_MAX_REPLANS
+from deeptutor.core.capability_protocol import (
+    StreamBusProtocol,
+    TurnCapability,
+)
+from deeptutor.core.context import UnifiedContext
+from deeptutor.runtime.bootstrap.builtin_capabilities import builtin_capability_manifest
+from deeptutor.runtime.stream_bus import StreamBus
+from deeptutor.services.config.capabilities_settings import get_solve_params
+
+logger = logging.getLogger(__name__)
+
+_UNSAFE_ID_CHARS = re.compile(r"[^A-Za-z0-9_-]")
+
+
+def _sanitize(raw: str) -> str:
+    cleaned = _UNSAFE_ID_CHARS.sub("_", raw).strip("_")
+    return cleaned or "default"
+
+
+def resolve_solve_session_id(context: UnifiedContext) -> str:
+    """Resolve the in-memory session key for this solve turn.
+
+    A solve turn is one-shot, so the turn id (falling back to the session /
+    message id) is enough to scope the plan + replan budget; concurrent turns
+    get distinct keys and never race.
+    """
+    raw = str(
+        context.metadata.get("turn_id")
+        or context.session_id
+        or context.metadata.get("message_id")
+        or "default"
+    )
+    return _sanitize(raw)
+
+
+class DeepSolveCapability(TurnCapability):
+    manifest = builtin_capability_manifest("deep_solve")
+
+    async def run(self, context: UnifiedContext, stream: StreamBusProtocol) -> None:
+        context.metadata["solve_mode"] = True
+        context.metadata["solve_session_id"] = resolve_solve_session_id(context)
+        # Read the solve settings and forward them so the page actually drives
+        # the loop: max_rounds → the loop's round budget, max_replans → the
+        # SolveSession gate (via metadata, read in SolveLoopCapability),
+        # temperature / max_tokens → the LLM calls.
+        try:
+            params = get_solve_params()
+        except Exception as exc:  # pragma: no cover - defensive config read
+            logger.warning("Failed to load solve params, using defaults: %s", exc)
+            params = {}
+        context.metadata["solve_max_replans"] = int(params.get("max_replans", DEFAULT_MAX_REPLANS))
+        pipeline = AgenticChatPipeline(
+            language=context.language,
+            max_rounds=params.get("max_rounds"),
+            temperature=params.get("temperature"),
+            max_tokens=params.get("max_tokens"),
+        )
+        await pipeline.run(context, cast(StreamBus, stream))
+
+
+__all__ = ["DeepSolveCapability", "resolve_solve_session_id"]

deeptutor/capabilities/solve/loop.py

@@ -0,0 +1,83 @@
+"""Deep Solve loop-capability hooks.
+
+Solve runs as the chat agent loop with a deterministic spine: a committed plan,
+a per-step done gate, and a bounded replan (the SolveSession + three owned
+tools), while the actual problem-solving happens at the loop's exit using the
+shared built-in tools. Active only when the turn is marked ``solve_mode`` by
+:class:`deeptutor.capabilities.solve.capability.DeepSolveCapability`.
+"""
+
+from __future__ import annotations
+
+from importlib import resources
+from typing import Any
+
+from deeptutor.capabilities.protocol import PromptBlock
+from deeptutor.capabilities.solve.session import DEFAULT_MAX_REPLANS, get_session
+from deeptutor.capabilities.solve.tools import SOLVE_TOOL_NAMES
+from deeptutor.core.context import UnifiedContext
+from deeptutor.services.prompt.lookup import prompt_text as _prompt_text
+
+
+class SolveLoopCapability:
+    """Turn-scoped integration for deep problem solving.
+
+    Reuses the full chat tool surface — every built-in, with the user's
+    composer toggles respected (web_search / reason / geogebra_analysis mount
+    iff the user enabled them, exactly as in chat) — and adds the solve spine
+    (plan / finish-step / replan) on top.
+    """
+
+    name = "solve"
+    owned_tools = SOLVE_TOOL_NAMES
+
+    def is_active(self, context: UnifiedContext) -> bool:
+        return bool(context.metadata.get("solve_mode"))
+
+    def system_block(
+        self,
+        context: UnifiedContext,
+        *,
+        language: str,
+        prompts: dict[str, Any],
+    ) -> PromptBlock | None:
+        if not self.is_active(context):
+            return None
+        override = _prompt_text(prompts, ("solve", "system"))
+        content = override or _load_system_prompt(language)
+        return PromptBlock("deep_solve", content)
+
+    def augment_kwargs(
+        self,
+        tool_name: str,
+        kwargs: dict[str, Any],
+        context: UnifiedContext,
+    ) -> dict[str, Any]:
+        if self.is_active(context) and tool_name in SOLVE_TOOL_NAMES:
+            session_id = str(context.metadata.get("solve_session_id") or "").strip()
+            # Seed the replan budget from the solve settings (the solve
+            # capability forwards ``max_replans`` into metadata); never the model.
+            session = get_session(session_id)
+            try:
+                session.max_replans = int(
+                    context.metadata.get("solve_max_replans", DEFAULT_MAX_REPLANS)
+                )
+            except (TypeError, ValueError):
+                session.max_replans = DEFAULT_MAX_REPLANS
+            updated = dict(kwargs)
+            updated["_solve_session_id"] = session_id
+            return updated
+        return kwargs
+
+    def pre_loop_seed(self, context: UnifiedContext) -> str:
+        _ = context
+        return ""
+
+
+def _load_system_prompt(language: str) -> str:
+    lang = "zh" if language.lower().startswith("zh") else "en"
+    prompt = resources.files(__package__).joinpath("prompts", lang, "system.md")
+    return prompt.read_text(encoding="utf-8").strip()
+
+
+__all__ = ["SolveLoopCapability"]

deeptutor/capabilities/solve/prompts/en/system.md

@@ -0,0 +1,13 @@
+[Deep Solve mode]
+You are solving a problem end to end. Be rigorous: plan, work each step with the right tool, and finish with a precise, well-explained answer.
+
+FIRST, before doing anything else, call `solve_plan` with a short analysis and an ordered list of steps (2-6 for most problems; a single step is fine for a trivial one). Never start solving before you have called `solve_plan`.
+
+Then work the plan one step at a time:
+- Do the step's actual work with the available tools, following each tool's schema and tool-specific guidance.
+- For a problem with a diagram, or a geometry problem where a figure helps, call `geogebra_analysis` to reconstruct the figure as a GeoGebra applet, then solve using it.
+- After finishing a step, call `solve_finish_step` with its id and a short summary of what it established. This records the result and frees up context. Do not skip steps; do not mark a step done before its work is actually complete.
+
+If an approach stalls or turns out wrong, call `solve_replan` with the reason and a new step list — but it is budget-limited, so use it only for a real course correction. If the budget is spent, finish with the best of what you have.
+
+When every step is done, write the final answer: state the precise result clearly, then give a concise, well-structured explanation of how you got there. Show the figure / file you produced if any.

deeptutor/capabilities/solve/prompts/zh/system.md

@@ -0,0 +1,13 @@
+[深度解题模式]
+你要把一道题从头到尾解出来。要严谨：先规划，再用合适的工具逐步求解，最后给出精确且讲解清晰的答案。
+
+**第一件事**：在做任何事之前，先调用 `solve_plan`，给出简短分析和一个有序的步骤列表（多数题目 2-6 步；很简单的题一步也行）。在调用 `solve_plan` 之前，绝不开始求解。
+
+然后按计划逐步推进，一次一步：
+- 用可用工具真正完成这一步，并遵循各工具的 schema 和工具专属说明。
+- 带配图的题、或画个图有助于理解的几何题，调用 `geogebra_analysis` 把图形还原成 GeoGebra 图形，再据此求解。
+- 完成一步后，调用 `solve_finish_step`，传入步骤 id 和这一步结论的简短总结。这会记录结果并释放上下文。不要跳步；不要在工作真正完成前就把步骤标记为完成。
+
+如果某个思路卡住或被证明走错了，调用 `solve_replan`，给出原因和新的步骤列表——但它有预算上限，只用于真正的方向修正。预算用尽就用现有结果收尾。
+
+所有步骤完成后，写出最终答案：先清楚地给出精确结果，再给出简洁、有条理的求解过程讲解。如生成了图形/文件，一并呈现。

deeptutor/capabilities/solve/session.py

@@ -0,0 +1,119 @@
+"""SolveSession — single-turn, in-memory state for the solve loop capability.
+
+Unlike mastery's learning service (disk-backed, multi-session), a solve turn
+is one-shot: the session lives only for the turn, keyed by the id the pipeline
+injects as ``_solve_session_id``. It holds the model-authored plan, per-step
+completion, and the replan budget gate — the deterministic "spine" the chat
+loop drives against. The plan also rides in the conversation — the
+``solve_plan`` tool result, then :meth:`SolveSession.progress_text` as the
+checkpoint state each ``solve_finish_step`` fold keeps — so a follow-up chat
+turn stays grounded even though the session itself does not persist.
+
+The store is a bounded, process-local dict: a solve turn runs in one process,
+sessions are small and short-lived, and the bound stops a long-running server
+from leaking. Concurrent turns use distinct ids, so they never race.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass, field
+
+DEFAULT_MAX_REPLANS = 2
+_MAX_STEPS = 12
+
+
+@dataclass
+class SolveStep:
+    """One plan step. ``done`` flips when the model calls ``solve_finish_step``."""
+
+    id: str
+    goal: str
+    done: bool = False
+    summary: str = ""
+
+    def to_dict(self) -> dict[str, object]:
+        return {"id": self.id, "goal": self.goal, "done": self.done}
+
+
+@dataclass
+class SolveSession:
+    """The plan + progress + replan budget for one solve turn."""
+
+    session_id: str
+    analysis: str = ""
+    steps: list[SolveStep] = field(default_factory=list)
+    replans: int = 0
+    max_replans: int = DEFAULT_MAX_REPLANS
+
+    def set_plan(self, analysis: str, steps: list[tuple[str, str]]) -> None:
+        self.analysis = analysis
+        self.steps = [SolveStep(id=sid, goal=goal) for sid, goal in steps][:_MAX_STEPS]
+
+    def replan(self, analysis: str, steps: list[tuple[str, str]]) -> bool:
+        """Replace the plan, bumping the replan counter. Returns ``False`` (and
+        leaves the plan untouched) once the budget is spent."""
+        if self.replans >= self.max_replans:
+            return False
+        self.replans += 1
+        self.set_plan(analysis, steps)
+        return True
+
+    def mark_done(self, step_id: str, summary: str) -> SolveStep | None:
+        for step in self.steps:
+            if step.id == step_id:
+                step.done = True
+                step.summary = summary.strip()
+                return step
+        return None
+
+    def next_step(self) -> SolveStep | None:
+        return next((step for step in self.steps if not step.done), None)
+
+    def map(self) -> list[dict[str, object]]:
+        return [step.to_dict() for step in self.steps]
+
+    def all_done(self) -> bool:
+        return bool(self.steps) and all(step.done for step in self.steps)
+
+    def progress_text(self) -> str:
+        """The plan as it stands — every step marked done / next / todo.
+
+        ``solve_finish_step`` hands this to the loop as checkpoint state, so the
+        plan stays in view after the step's tool chatter is folded away.
+        """
+        nxt = self.next_step()
+        lines = ["[Solve plan]"]
+        for step in self.steps:
+            mark = "done" if step.done else ("next" if step is nxt else "todo")
+            lines.append(f"- {step.id} [{mark}] {step.goal}")
+        lines.append(
+            "All steps are done: write the final answer now."
+            if nxt is None
+            else f"Work {nxt.id} now, then call solve_finish_step."
+        )
+        return "\n".join(lines)
+
+
+_SESSIONS: "OrderedDict[str, SolveSession]" = OrderedDict()
+_MAX_SESSIONS = 256
+
+
+def get_session(session_id: str) -> SolveSession:
+    """Fetch (or lazily create) the turn's session, evicting oldest past cap."""
+    sid = (session_id or "").strip() or "default"
+    session = _SESSIONS.get(sid)
+    if session is None:
+        session = SolveSession(session_id=sid)
+        _SESSIONS[sid] = session
+        while len(_SESSIONS) > _MAX_SESSIONS:
+            _SESSIONS.popitem(last=False)
+    return session
+
+
+__all__ = [
+    "DEFAULT_MAX_REPLANS",
+    "SolveSession",
+    "SolveStep",
+    "get_session",
+]

deeptutor/capabilities/solve/tools.py

@@ -0,0 +1,313 @@
+"""Solve tools — the seam between the chat-loop solver and the SolveSession.
+
+Three tools auto-mounted only when a solve turn is active (via the solve loop
+capability). The chat agent loop IS the solver; these tools give it a deterministic
+spine — a plan it commits to, a per-step "done" gate, and a bounded replan —
+while the reasoning (how to actually solve each step) stays the model's job in
+the loop, using the shared built-in tools (rag / exec / geogebra / …).
+
+The active session id is injected server-side by the pipeline as
+``_solve_session_id``; the model never supplies it. ``solve_finish_step`` emits
+a ``_context_checkpoint`` so the loop folds the just-finished step's tool
+chatter into a one-line summary — the loop-native equivalent of the old
+pipeline's per-step message reset — and carries the current plan as the
+checkpoint's ``state``, which each fold replaces with the latest copy.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from deeptutor.capabilities.solve.session import get_session
+from deeptutor.core.tool_protocol import BaseTool, ToolDefinition, ToolParameter, ToolResult
+
+# Tool names the pipeline mounts together when a solve turn is active. Kept
+# here so the mount policy and the registration list can't disagree.
+SOLVE_TOOL_NAMES: tuple[str, ...] = (
+    "solve_plan",
+    "solve_finish_step",
+    "solve_replan",
+)
+
+
+def _resolve_session_id(kwargs: dict[str, Any]) -> str:
+    return str(kwargs.get("_solve_session_id") or "").strip()
+
+
+def _json_result(
+    payload: dict[str, Any], *, meta_key: str, extra_meta: dict[str, Any] | None = None
+) -> ToolResult:
+    metadata: dict[str, Any] = {meta_key: payload}
+    if extra_meta:
+        metadata.update(extra_meta)
+    return ToolResult(
+        content=json.dumps(payload, ensure_ascii=False),
+        success=True,
+        metadata=metadata,
+    )
+
+
+def _no_session_result() -> ToolResult:
+    return ToolResult(
+        content="No solve session is active on this turn; solve tools are unavailable.",
+        success=False,
+    )
+
+
+def _parse_steps(raw_steps: Any) -> list[tuple[str, str]]:
+    """Validate the model-authored step list into ``(id, goal)`` pairs.
+
+    Ids are server-generated (``S1``, ``S2``, …) so the model never controls
+    storage keys; steps without a goal are dropped.
+    """
+    if not isinstance(raw_steps, list):
+        return []
+    steps: list[tuple[str, str]] = []
+    for i, raw in enumerate(raw_steps):
+        if isinstance(raw, dict):
+            goal = str(raw.get("goal") or "").strip()
+        else:
+            goal = str(raw or "").strip()
+        if not goal:
+            continue
+        steps.append((f"S{len(steps) + 1}", goal))
+    return steps
+
+
+class SolvePlanTool(BaseTool):
+    """Commit to a step plan for the problem. Call FIRST on a solve turn."""
+
+    def get_definition(self) -> ToolDefinition:
+        return ToolDefinition(
+            name="solve_plan",
+            description=(
+                "Lay out your plan for solving the problem: a short analysis plus "
+                "an ordered list of steps. Call this FIRST, before doing any work. "
+                "Then work the steps one at a time with the available tools, "
+                "calling solve_finish_step after each. Keep the plan tight (2-6 "
+                "steps); for a trivial problem a single step is fine."
+            ),
+            parameters=[
+                ToolParameter(
+                    name="analysis",
+                    type="string",
+                    description="One or two sentences: what the problem asks and your approach.",
+                ),
+                ToolParameter(
+                    name="steps",
+                    type="array",
+                    description="Ordered steps, each {goal}. Goals are short imperative phrases.",
+                    items={
+                        "type": "object",
+                        "properties": {"goal": {"type": "string"}},
+                        "required": ["goal"],
+                    },
+                ),
+            ],
+        )
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        session_id = _resolve_session_id(kwargs)
+        if not session_id:
+            return _no_session_result()
+        steps = _parse_steps(kwargs.get("steps"))
+        if not steps:
+            return ToolResult(
+                content="solve_plan needs a non-empty 'steps' array, each with a 'goal'.",
+                success=False,
+            )
+        analysis = str(kwargs.get("analysis") or "").strip()
+        session = get_session(session_id)
+        if session.steps:
+            # A second solve_plan would wipe progress and skip the replan budget.
+            return ToolResult(
+                content=json.dumps(
+                    {
+                        "status": "plan_exists",
+                        "plan": session.progress_text(),
+                        "instruction": (
+                            "A plan is already set. Continue it; call solve_replan "
+                            "only if the approach has genuinely failed."
+                        ),
+                    },
+                    ensure_ascii=False,
+                ),
+                success=False,
+                metadata={"solve_plan": {"status": "plan_exists"}},
+            )
+        session.set_plan(analysis, steps)
+        first = session.next_step()
+        return _json_result(
+            {
+                "status": "planned",
+                "analysis": analysis,
+                "steps": session.map(),
+                "next": first.to_dict() if first else None,
+                "instruction": (
+                    "Work the first step now using the available tools, then call "
+                    "solve_finish_step with a short summary of its result. Do not "
+                    "skip steps."
+                ),
+            },
+            meta_key="solve_plan",
+        )
+
+
+class SolveFinishStepTool(BaseTool):
+    """Record a step as done and advance; folds the step's chatter to a summary."""
+
+    def get_definition(self) -> ToolDefinition:
+        return ToolDefinition(
+            name="solve_finish_step",
+            description=(
+                "Mark the current step done and move on. Pass a short summary of "
+                "what the step established (the key result / value / conclusion) — "
+                "this is kept as the step's record while its intermediate tool "
+                "output is folded away to save context. Returns the next step to "
+                "work on, or signals that all steps are done."
+            ),
+            parameters=[
+                ToolParameter(
+                    name="step_id",
+                    type="string",
+                    description="The step id from solve_plan (e.g. 'S1').",
+                ),
+                ToolParameter(
+                    name="summary",
+                    type="string",
+                    description="Short summary of the step's result, kept as its record.",
+                ),
+            ],
+        )
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        session_id = _resolve_session_id(kwargs)
+        if not session_id:
+            return _no_session_result()
+        step_id = str(kwargs.get("step_id") or "").strip()
+        summary = str(kwargs.get("summary") or "").strip()
+        session = get_session(session_id)
+        if not session.steps:
+            return ToolResult(
+                content="No plan yet. Call solve_plan before solve_finish_step.",
+                success=False,
+            )
+        step = session.mark_done(step_id, summary)
+        if step is None:
+            return ToolResult(
+                content=f"Unknown step {step_id!r}; valid ids: {[s.id for s in session.steps]}.",
+                success=False,
+            )
+        nxt = session.next_step()
+        payload = {
+            "status": "step_done",
+            "completed": step_id,
+            "next": nxt.to_dict() if nxt else None,
+            "all_done": session.all_done(),
+            "instruction": (
+                "Write the final answer now."
+                if nxt is None
+                else "Work the next step, then call solve_finish_step again."
+            ),
+        }
+        # The checkpoint summary persists this step's outcome while the loop
+        # folds its intermediate tool messages away (see AgentLoop). The fold
+        # also drops this result and the solve_plan one, so the plan rides
+        # along as checkpoint state: the loop keeps only its latest copy.
+        checkpoint = f"[{step.id}] {step.goal} — done. {summary}".strip()
+        return _json_result(
+            payload,
+            meta_key="solve_finish_step",
+            extra_meta={
+                "_context_checkpoint": {"summary": checkpoint, "state": session.progress_text()}
+            },
+        )
+
+
+class SolveReplanTool(BaseTool):
+    """Discard the current plan for a new one when the approach is stuck."""
+
+    def get_definition(self) -> ToolDefinition:
+        return ToolDefinition(
+            name="solve_replan",
+            description=(
+                "Replace the plan when the current approach has stalled or proved "
+                "wrong. Give the reason and a fresh ordered list of steps. This is "
+                "budget-limited — use it only for a genuine course correction, not "
+                "minor tweaks. If the budget is spent, finish with what you have."
+            ),
+            parameters=[
+                ToolParameter(
+                    name="reason",
+                    type="string",
+                    description="Why the current plan failed and what changes.",
+                ),
+                ToolParameter(
+                    name="steps",
+                    type="array",
+                    description="The new ordered steps, each {goal}.",
+                    items={
+                        "type": "object",
+                        "properties": {"goal": {"type": "string"}},
+                        "required": ["goal"],
+                    },
+                ),
+            ],
+        )
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        session_id = _resolve_session_id(kwargs)
+        if not session_id:
+            return _no_session_result()
+        steps = _parse_steps(kwargs.get("steps"))
+        if not steps:
+            return ToolResult(
+                content="solve_replan needs a non-empty 'steps' array, each with a 'goal'.",
+                success=False,
+            )
+        reason = str(kwargs.get("reason") or "").strip()
+        session = get_session(session_id)
+        if not session.replan(reason, steps):
+            return ToolResult(
+                content=json.dumps(
+                    {
+                        "status": "budget_exhausted",
+                        "instruction": (
+                            "Replan budget is spent. Do not replan again — finish "
+                            "the problem with the best of what you have."
+                        ),
+                    },
+                    ensure_ascii=False,
+                ),
+                success=False,
+                metadata={"solve_replan": {"status": "budget_exhausted"}},
+            )
+        first = session.next_step()
+        return _json_result(
+            {
+                "status": "replanned",
+                "reason": reason,
+                "replans_used": session.replans,
+                "replans_max": session.max_replans,
+                "steps": session.map(),
+                "next": first.to_dict() if first else None,
+            },
+            meta_key="solve_replan",
+        )
+
+
+SOLVE_TOOL_TYPES: tuple[type[BaseTool], ...] = (
+    SolvePlanTool,
+    SolveFinishStepTool,
+    SolveReplanTool,
+)
+
+
+__all__ = [
+    "SOLVE_TOOL_NAMES",
+    "SOLVE_TOOL_TYPES",
+    "SolveFinishStepTool",
+    "SolvePlanTool",
+    "SolveReplanTool",
+]

deeptutor/tools/solve_tool.py

@@ -0,0 +1,22 @@
+"""Compatibility exports for solve loop-plugin tools.
+
+The solve loop capability owns the implementation under
+``deeptutor.capabilities.solve.tools``. This module keeps a stable import path
+for the built-in tool registry and any external users.
+"""
+
+from deeptutor.capabilities.solve.tools import (
+    SOLVE_TOOL_NAMES,
+    SOLVE_TOOL_TYPES,
+    SolveFinishStepTool,
+    SolvePlanTool,
+    SolveReplanTool,
+)
+
+__all__ = [
+    "SOLVE_TOOL_NAMES",
+    "SOLVE_TOOL_TYPES",
+    "SolveFinishStepTool",
+    "SolvePlanTool",
+    "SolveReplanTool",
+]

deeptutor_solve-1.7.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: deeptutor-solve
+Version: 1.7.0
+Summary: DeepTutor solve module
+Requires-Python: <3.15,>=3.11
+Requires-Dist: deeptutor==1.7.0

deeptutor_solve-1.7.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+deeptutor/capabilities/solve/__init__.py,sha256=-SLqq9qs1Z57g-zU5JWnAINn30lexonDvUQrlckhWZY,258
+deeptutor/capabilities/solve/capability.py,sha256=rOrLDd6agmohY95xrvf-kRXICDjQ6aFzgyx_LqGRj1Y,3526
+deeptutor/capabilities/solve/loop.py,sha256=WPVUm4g-rpQrH_deij3UE_VRZQ01v_RGRptJd7sZD-s,3074
+deeptutor/capabilities/solve/session.py,sha256=Aixs2rHchSnzBmlD9h9d0OIu4s9D-OHJ55o5Y1Ac7_4,4151
+deeptutor/capabilities/solve/tools.py,sha256=2cxeUDLOYYu0hsWWDzv4iYkJZGqeWrbEYGGavlMuNU0,11946
+deeptutor/capabilities/solve/prompts/en/system.md,sha256=6yzoeqDZtrNzEqwy56iTwZ434EyZL1rzledEvEO_BBk,1380
+deeptutor/capabilities/solve/prompts/zh/system.md,sha256=sb6jKczaCBmEARoTTyM55PlLloP1qdHMMpt_pd1R2Ts,1285
+deeptutor/tools/solve_tool.py,sha256=JYnzNFKJYNDkzDZTvS6jOBn_Hs4PFIt6LU7dci6DwDI,544
+deeptutor_solve-1.7.0.dist-info/METADATA,sha256=k_7DzztRgLQpZCdP3KUlxYFViEyOnTmhwgXq8q6-cgU,153
+deeptutor_solve-1.7.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+deeptutor_solve-1.7.0.dist-info/top_level.txt,sha256=hnSHUG_vphMnHpT-DbMqcemCKadJ24laFGAWlovG2xM,10
+deeptutor_solve-1.7.0.dist-info/RECORD,,

deeptutor_solve-1.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deeptutor_solve-1.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+deeptutor