fabricatio 0.2.8.dev2__cp312-cp312-win_amd64.whl → 0.2.8.dev3__cp312-cp312-win_amd64.whl

fabricatio/models/extra/article_essence.py

@@ -2,267 +2,98 @@
 
 from typing import List, Self
 
-from fabricatio.models.generic import Display, PersistentAble, PrepareVectorization, ProposedAble
-from pydantic import BaseModel, Field
+from fabricatio.models.generic import Display, PersistentAble, ProposedAble, Vectorizable
+from pydantic import BaseModel
 
 
 class Equation(BaseModel):
-    """Mathematical formalism specification for research contributions.
-
-    Encodes equations with dual representation: semantic meaning and typeset-ready notation.
-    """
+    """Mathematical formalism specification for research contributions."""
 
     description: str
-    """Equation significance structured in three elements:
-    1. Physical/conceptual meaning of the equation.
-    2. Role in technical workflow (e.g., derivation, optimization, or analysis).
-    3. Relationship to the paper's core contribution (e.g., theoretical foundation, empirical validation).
-    Example: "Defines constrained search space dimensionality reduction. Used in architecture optimization phase (Section 3.2). Enables 40% parameter reduction."
+    """Structured significance including:
+    1. Conceptual meaning
+    2. Technical workflow role
+    3. Contribution relationship
     """
 
-    typst_code: str
-    r"""The typst code for the equation, including the equation itself and any necessary formatting.
-#let x = 5  // Define a code variable
-
-// Basic syntax examples
-$x^2$  // Inline formula
-$ x^2 $  // Block formula (spaces before/after $ for standalone display)
-
-// Variables and text handling
-$ A = pi r^2 $  // Single-letter variables as-is
-$"area" = pi dot "radius"^2 $  // Multi-letter variables in quotes
-$ cal(A) := { x in RR | x "is natural" } $  // Calligraphic font and text
-$ #x < 17 $  // Access code variables with #
-
-// Symbols and shorthands
-$x < y => x gt.eq.not y $  // Symbol shorthand (=> for ⇒, gt.eq.not for ≯)
-
-// Multi-line equations with alignment
-$ sum_(k=0)^n k
-    &= 1 + ... + n \
-    &= (n(n+1))/2 $  // Multi-line with & alignment
-
-// Function calls and formatting
-$ frac(a^2, 2) $  // Fraction
-$ vec(1, 2, delim: "[") $  // Custom vector delimiter
-$ mat(1, 2; 3, 4) $  // 2D matrix (semicolon separates rows)
-$ mat(..#range(1, 5).chunks(2)) $  // Dynamic matrix with array expansion
-
-// Advanced alignment example
-$ (3x + y)/7 &= 9 && "given" \
-  3x + y    &= 63 & "multiply by 7" \
-  3x        &= 63 - y && "subtract y" \
-  x         &= 21 - y/3 & "divide by 3" $
-// && skips a column alignment (left/right alternation)
-
-// Math font configuration
-#show math.equation: set text(font: "Fira Math")  // Set math font (requires Fira Math installed)
-$ sum_(i in NN) 1 + i $  // Display with new font
-
-// Escaping and special syntax
-$ frac(a\,, b) $  // Escape comma to display as literal
-$ f(x; y) $  // Literal semicolon (not for 2D arrays)
-$ lim_x = op("lim", limits: #true)_x $  // Custom operator with limits
-    """
+    latex_code: str
+    """Typeset-ready notation."""
 
 
 class Figure(BaseModel):
-    """Visual component specification for technical communication.
-
-    Combines graphical assets with structured academic captioning.Extracted from the article provided
-    """
+    """Visual component with academic captioning."""
 
     description: str
-    """Figure interpretation guide containing:
-    1. Key visual elements mapping (e.g., axes, legends, annotations).
-    2. Data representation methodology (e.g., visualization type, statistical measures).
-    3. Connection to research findings (e.g., supports hypothesis, demonstrates performance).
-    Example: "Architecture search space topology (left) vs. convergence curves (right). Demonstrates NAS efficiency gains through constrained search."
+    """Interpretation guide covering:
+    1. Visual element mapping
+    2. Data representation method
+    3. Research connection
     """
 
     figure_caption: str
-    """Complete caption following Nature-style guidelines:
-    1. Brief overview statement (首句总结).
-    2. Technical detail layer (e.g., data sources, experimental conditions).
-    3. Result implication (e.g., key insights, implications for future work).
-    Example: "Figure 3: Differentiable NAS framework. (a) Search space topology with constrained dimensions. (b) Training convergence across language pairs. Dashed lines indicate baseline methods."
+    """Nature-style caption containing:
+    1. Overview statement
+    2. Technical details
+    3. Result implications
     """
 
     figure_serial_number: int
-    """The Image serial number extracted from the Markdown article provided, the path usually in the form of `![](images/1.jpg)`, in this case the serial number is `1`"""
-
-
-class Algorithm(BaseModel):
-    """Algorithm specification for research contributions."""
-
-    title: str
-    """Algorithm title with technical focus descriptor (e.g., 'Gradient Descent Optimization').
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
-
-    description: str
-    """Algorithm description with technical focus descriptor:
-    - Includes input/output specifications.
-    - Describes key steps and their purpose.
-    - Explains its role in the research workflow.
-    Example: "Proposed algorithm for neural architecture search. Inputs include search space constraints and training data. Outputs optimized architecture."
-    """
-
-
-class Table(BaseModel):
-    """Table specification for research contributions."""
-
-    title: str
-    """Table title with technical focus descriptor (e.g., 'Comparison of Model Performance Metrics').
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
-
-    description: str
-    """Table description with technical focus descriptor:
-    - Includes data source and structure.
-    - Explains key columns/rows and their significance.
-    - Connects to research findings or hypotheses.
-    Example: "Performance metrics for different architectures. Columns represent accuracy, F1-score, and inference time. Highlights efficiency gains of proposed method."
-    """
+    """Image serial number extracted from Markdown path"""
 
 
 class Highlightings(BaseModel):
-    """Technical showcase aggregator for research artifacts.
-
-    Curates core scientific components with machine-parseable annotations.
-    """
+    """Technical component aggregator."""
 
     highlighted_equations: List[Equation]
-    """3-5 pivotal equations representing theoretical contributions:
-    - Each equation must be wrapped in $$ for display math.
-    - Contain at least one novel operator/symbol.
-    - Be referenced in Methods/Results sections.
-    Example: Equation describing proposed loss function.
-    """
-
-    highlighted_algorithms: List[Algorithm]
-    """1-2 key algorithms demonstrating methodological contributions:
-    - Include pseudocode or step-by-step descriptions.
-    - Highlight innovation in computational approach.
-    Example: Algorithm for constrained search space exploration.
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
-    """
+    """Equations that highlight the article's core contributions"""
 
     highlighted_figures: List[Figure]
-    """4-6 key figures demonstrating:
-    1. Framework overview (1 required).
-    2. Quantitative results (2-3 required).
-    3. Ablation studies (1 optional).
-    Each must appear in Results/Discussion chapters.
-    Example: Figure showing architecture topology and convergence curves.
-    """
-
-    highlighted_tables: List[Table]
-    """2-3 key tables summarizing:
-    - Comparative analysis of methods.
-    - Empirical results supporting claims.
-    Example: Table comparing model performance across datasets.
-
-    Tip: Do not attempt to translate the original element titles when generating JSON.
+    """key figures requiring:
+    1. Framework overview
+    2. Quantitative results
     """
 
 
-class ArticleEssence(ProposedAble, Display, PersistentAble, PrepareVectorization):
-    """ArticleEssence is a structured representation of the core elements of a scientific article,using its original language."""
+class ArticleEssence(ProposedAble, Display, PersistentAble, Vectorizable):
+    """Structured representation of a scientific article's core elements in its original language."""
 
     language: str
-    """Language of the original article, note that you should not attempt to translate the original language when generating JSON."""
+    """Language of the original article."""
 
-    title: str = Field(...)
-    """Exact title of the original article without any modification.
-    Must be preserved precisely from the source material without:
-    - Translation
-    - Paraphrasing
-    - Adding/removing words
-    - Altering style or formatting
-    """
+    title: str
+    """Exact title of the original article."""
 
     authors: List[str]
-    """Original author full names exactly as they appear in the source document. No translation or paraphrasing.
-    Extract complete list without any modifications or formatting changes."""
+    """Original author full names as they appear in the source document."""
 
     keywords: List[str]
-    """Original keywords exactly as they appear in the source document. No translation or paraphrasing.
-    Extract the complete set without modifying format or terminology."""
+    """Original keywords as they appear in the source document."""
 
     publication_year: int
-    """Publication timestamp in ISO 8601 (YYYY format)."""
+    """Publication year in ISO 8601 (YYYY format)."""
 
     highlightings: Highlightings
-    """Technical highlight reel containing:
-    - Core equations (Theory)
-    - Key algorithms (Implementation)
-    - Critical figures (Results)
-    - Benchmark tables (Evaluation)"""
+    """Technical highlights including equations, algorithms, figures, and tables."""
 
-    domain: List[str]
-    """Domain tags for research focus."""
-
-    abstract: str = Field(...)
-    """Abstract text with original language."""
+    abstract: str
+    """Abstract text in the original language."""
 
     core_contributions: List[str]
-    """3-5 technical contributions using CRediT taxonomy verbs.
-    Each item starts with action verb.
-    Example:
-    - 'Developed constrained NAS framework'
-    - 'Established cross-lingual transfer metrics'"""
+    """Technical contributions using CRediT taxonomy verbs."""
 
     technical_novelty: List[str]
-
-    """Patent-style claims with technical specificity.
-    Format: 'A [system/method] comprising [novel components]...'
-    Example:
-    'A neural architecture search system comprising:
-     a differentiable constrained search space;
-     multi-lingual transferability predictors...'"""
+    """Patent-style claims with technical specificity."""
 
     research_problems: List[str]
-    """Problem statements as how/why questions.
-    Example:
-    - 'How to reduce NAS computational overhead while maintaining search diversity?'
-    - 'Why do existing architectures fail in low-resource cross-lingual transfer?'"""
+    """Problem statements as how/why questions."""
 
     limitations: List[str]
-    """Technical limitations analysis containing:
-    1. Constraint source (data/method/theory)
-    2. Impact quantification
-    3. Mitigation pathway
-    Example:
-    'Methodology constraint: Single-objective optimization (affects 5% edge cases),
-    mitigated through future multi-task extension'"""
-
-    future_work: List[str]
-    """Research roadmap items with 3 horizons:
-    1. Immediate extensions (1 year)
-    2. Mid-term directions (2-3 years)
-    3. Long-term vision (5+ years)
-    Example:
-    'Short-term: Adapt framework for vision transformers (ongoing with CVPR submission)'"""
-
-    impact_analysis: List[str]
-    """Bibliometric impact projections:
-    - Expected citation counts (next 3 years)
-    - Target application domains
-    - Standard adoption potential
-    Example:
-    'Predicted 150+ citations via integration into MMEngine (Alibaba OpenMMLab)'"""
+    """Technical limitations analysis."""
 
     bibtex_cite_key: str
-    """Bibtex cite_key of the original article."""
+    """Bibtex cite key of the original article."""
 
     def update_cite_key(self, new_cite_key: str) -> Self:
         """Update the bibtex_cite_key of the article."""
         self.bibtex_cite_key = new_cite_key
         return self
-
-    def _prepare_vectorization_inner(self) -> str:
-        return self.model_dump_json()

fabricatio/models/extra/article_main.py

@@ -16,7 +16,7 @@ from fabricatio.models.extra.article_outline import (
     ArticleOutline,
 )
 from fabricatio.models.generic import CensoredAble, Display, PersistentAble, WithRef
-from fabricatio.models.utils import ok
+from fabricatio.utils import ok
 
 
 class Paragraph(CensoredAble):

fabricatio/models/extra/problem.py

@@ -0,0 +1,120 @@
+"""A class representing a problem-solution pair identified during a review process."""
+
+from typing import List, Literal, Self
+
+from fabricatio.models.generic import Display, ProposedAble, ProposedUpdateAble, WithBriefing
+from fabricatio.utils import ask_edit
+from questionary import Choice, checkbox, text
+from rich import print as r_print
+
+
+class Problem(ProposedAble, WithBriefing, Display):
+    """Represents a problem identified during review."""
+
+    description: str
+    """Description of the problem, The """
+
+    severity: Literal["low", "medium", "high"]
+    """Severity level of the problem."""
+
+    category: str
+    """Category of the problem."""
+
+    location: str
+    """Location where the problem was identified."""
+
+    recommendation: str
+    """Recommended solution or action."""
+
+
+class Solution(ProposedAble, WithBriefing, Display):
+    """Represents a proposed solution to a problem."""
+
+    operation: str
+    """Description or identifier of the operation."""
+
+    feasibility: Literal["low", "medium", "high"]
+    """Feasibility level of the solution."""
+
+    impact: Literal["low", "medium", "high"]
+    """Impact level of the solution."""
+
+
+class ProblemSolutions(ProposedUpdateAble):
+    """Represents a problem-solution pair identified during a review process."""
+
+    problem: Problem
+    """The problem identified in the review."""
+    solutions: List[Solution]
+    """A collection of potential solutions."""
+
+    def update_from_inner(self, other: Self) -> Self:
+        """Update the current instance with another instance's attributes."""
+        self.solutions.clear()
+        self.solutions.extend(other.solutions)
+        return self
+
+    def update_problem(self, problem: Problem) -> Self:
+        """Update the problem description."""
+        self.problem = problem
+        return self
+
+    def update_solutions(self, solutions: List[Solution]) -> Self:
+        """Update the list of potential solutions."""
+        self.solutions = solutions
+        return self
+
+    async def edit_problem(self) -> Self:
+        """Interactively edit the problem description."""
+        self.problem = Problem.model_validate_strings(
+            await text("Please edit the problem below:", default=self.problem.display()).ask_async()
+        )
+        return self
+
+    async def edit_solutions(self) -> Self:
+        """Interactively edit the list of potential solutions."""
+        r_print(self.problem.display())
+        string_seq = await ask_edit([s.display() for s in self.solutions])
+        self.solutions = [Solution.model_validate_strings(s) for s in string_seq]
+        return self
+
+
+class Improvement(ProposedAble, Display):
+    """A class representing an improvement suggestion."""
+
+    problem_solutions: List[ProblemSolutions]
+    """Collection of problems identified during review along with their potential solutions."""
+
+    async def supervisor_check(self, check_solutions: bool = True) -> Self:
+        """Perform an interactive review session to filter problems and solutions.
+
+        Presents an interactive prompt allowing a supervisor to select which
+        problems (and optionally solutions) should be retained in the final review.
+
+        Args:
+            check_solutions (bool, optional): When True, also prompts for filtering
+                individual solutions for each retained problem. Defaults to False.
+
+        Returns:
+            Self: The current instance with filtered problems and solutions.
+        """
+        # Choose the problems to retain
+        chosen_ones: List[ProblemSolutions] = await checkbox(
+            "Please choose the problems you want to retain.(Default: retain all)",
+            choices=[Choice(p.problem.name, p, checked=True) for p in self.problem_solutions],
+        ).ask_async()
+        self.problem_solutions = [await p.edit_problem() for p in chosen_ones]
+        if not check_solutions:
+            return self
+
+        # Choose the solutions to retain
+        for to_exam in self.problem_solutions:
+            to_exam.update_solutions(
+                await checkbox(
+                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
+                    choices=[Choice(s.name, s, checked=True) for s in to_exam.solutions],
+                ).ask_async()
+            )
+            await to_exam.edit_solutions()
+
+        return self

fabricatio/models/extra/rule.py

@@ -0,0 +1,23 @@
+"""A module containing classes related to rule sets and rules."""
+
+from typing import List
+
+from fabricatio.models.generic import Described, Display, PersistentAble, ProposedAble, WithBriefing
+
+
+class Rule(WithBriefing,ProposedAble,Display):
+    """Represents a rule or guideline for a specific topic."""
+
+    violation_examples: List[str]
+    """Examples of violations of the rule."""
+    compliance_examples: List[str]
+    """Examples of how to comply with the rule."""
+
+
+class RuleSet(ProposedAble, Display, PersistentAble, Described):
+    """Represents a collection of rules and guidelines for a particular topic."""
+
+    title: str
+    """The title of the rule set."""
+    rules: List[Rule]
+    """The rules and guidelines contained in the rule set."""

fabricatio/models/generic.py

@@ -6,13 +6,15 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final, overload
 
 import orjson
+import rtoml
 from fabricatio._rust import blake3_hash
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.fs.readers import MAGIKA, safe_text_read
 from fabricatio.journal import logger
-from fabricatio.models.utils import ok
 from fabricatio.parser import JsonCapture
+from fabricatio.utils import ok
+from litellm.utils import token_counter
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -63,7 +65,7 @@ class Named(Base):
 class Described(Base):
     """Class that includes a description attribute."""
 
-    description: str = Field(default="", frozen=True)
+    description: str = Field(frozen=True)
     """The description of the object."""
 
 
@@ -98,14 +100,28 @@ class WithRef[T](Base):
             self._reference, f"`{self.__class__.__name__}`' s `_reference` field is None. Have you called `update_ref`?"
         )
 
-    def update_ref[S: "WithRef"](self: S, reference: T | S) -> S:  # noqa: PYI019
+    @overload
+    def update_ref[S: WithRef](self: S, reference: T) -> S: ...
+
+    @overload
+    def update_ref[S: WithRef](self: S, reference: "WithRef[T]") -> S: ...
+
+    @overload
+    def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
+    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:  # noqa: PYI019
         """Update the reference of the object."""
         if isinstance(reference, self.__class__):
             self._reference = reference.referenced
         else:
-            self._reference = reference
+            self._reference = reference  # pyright: ignore [reportAttributeAccessIssue]
         return self
 
+    def derive[S: WithRef](self: S, reference: Any) -> S:  # noqa: PYI019
+        """Derive a new object from the current object."""
+        new = self.model_copy()
+        new._reference = reference
+        return new
+
 
 class PersistentAble(Base):
     """Class that provides a method to persist the object."""
@@ -120,10 +136,10 @@ class PersistentAble(Base):
             Self: The current instance of the object.
         """
         p = Path(path)
-        out = self.model_dump_json(indent=1)
+        out = rtoml.dumps(self.model_dump())
 
         # Generate a timestamp in the format YYYYMMDD_HHMMSS
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        timestamp = datetime.now().strftime("%Y%m%d")
 
         # Generate the hash
         file_hash = blake3_hash(out.encode())[:6]
@@ -150,7 +166,7 @@ class PersistentAble(Base):
         Returns:
             Self: The current instance of the object.
         """
-        return cls.model_validate_json(Path(path).read_text(encoding="utf-8"))
+        return cls.model_validate(rtoml.load(path))
 
 
 class ModelHash(Base):
@@ -220,27 +236,6 @@ class WithBriefing(Named, Described):
         """
         return f"{self.name}: {self.description}" if self.description else self.name
 
-    def _prepend_inner(self, input_text: str) -> str:
-        return f"# your personal briefing: \n{self.briefing}\n{input_text}"
-
-    def prepend_sys_msg[D: (Dict[str, Any], str)](self, system_msg_like: D = "") -> Dict[str, Any]:
-        """Prepend the system message with the briefing.
-
-        Args:
-            system_msg_like (str | dict): The system message or a dictionary containing the system message.
-
-        Returns:
-            dict: The system message with the briefing prepended.
-        """
-        match system_msg_like:
-            case dict(d):
-                d["system_message"] = self._prepend_inner(d.get("system_message", ""))
-                return d
-            case str(s):
-                return {"system_message": self._prepend_inner(s)}
-            case _:
-                raise TypeError(f"{system_msg_like} is not a dict or str")
-
 
 class UnsortGenerate(GenerateJsonSchema):
     """Class that provides a reverse JSON schema of the model."""
@@ -441,13 +436,13 @@ class WithDependency(Base):
         )
 
 
-class PrepareVectorization(Base):
+class Vectorizable(Base):
     """Class that prepares the vectorization of the model."""
 
-    @abstractmethod
     def _prepare_vectorization_inner(self) -> str:
-        """Prepare the vectorization of the model."""
+        return rtoml.dumps(self.model_dump())
 
+    @final
     def prepare_vectorization(self, max_length: Optional[int] = None) -> str:
         """Prepare the vectorization of the model.
 
@@ -456,8 +451,8 @@ class PrepareVectorization(Base):
         """
         max_length = max_length or configs.embedding.max_sequence_length
         chunk = self._prepare_vectorization_inner()
-        if max_length and len(chunk) > max_length:
-            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}.")
+        if max_length and (length := token_counter(text=chunk)) > max_length:
+            logger.error(err := f"Chunk exceeds maximum sequence length {max_length}, got {length},see {chunk}")
             raise ValueError(err)
 
         return chunk

fabricatio/models/role.py

@@ -8,11 +8,12 @@ from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
 from fabricatio.models.events import Event
+from fabricatio.models.generic import WithBriefing
 from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, Correct):
+class Role(WithBriefing, ProposeTask, HandleTask, Correct):
     """Class that represents a role with a registry of events and workflows.
 
     A Role serves as a container for workflows, managing their registration to events
@@ -22,6 +23,8 @@ class Role(ProposeTask, HandleTask, Correct):
         registry: Mapping of events to workflows that handle them
         toolboxes: Set of toolboxes available to this role and its workflows
     """
+    description:str =""
+    """A brief description of the role's responsibilities and capabilities."""
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
     """The registry of events and workflows."""

fabricatio/models/usages.py

@@ -14,8 +14,9 @@ from fabricatio.models.generic import ScopedConfig, WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
-from fabricatio.models.utils import Messages, ok
+from fabricatio.models.utils import Messages
 from fabricatio.parser import GenericCapture, JsonCapture
+from fabricatio.utils import ok
 from litellm import RateLimitError, Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
@@ -280,7 +281,7 @@ class LLMUsage(ScopedConfig):
         question: str | List[str],
         validator: Callable[[str], T | None],
         default: Optional[T] = None,
-        max_validations: PositiveInt = 2,
+        max_validations: PositiveInt = 3,
         co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T] | List[Optional[T]] | List[T] | T:
@@ -338,7 +339,7 @@ class LLMUsage(ScopedConfig):
 
         return await (gather(*[_inner(q) for q in question]) if isinstance(question, list) else _inner(question))
 
-    async def aliststr(
+    async def alist_str(
         self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[ValidateKwargs[List[str]]]
     ) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
@@ -360,6 +361,7 @@ class LLMUsage(ScopedConfig):
             **kwargs,
         )
 
+
     async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs[List[str]]]) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
 
@@ -370,7 +372,7 @@ class LLMUsage(ScopedConfig):
         Returns:
             List[str]: The validated response as a list of strings.
         """
-        return await self.aliststr(
+        return await self.alist_str(
             TEMPLATE_MANAGER.render_template(
                 configs.templates.pathstr_template,
                 {"requirement": requirement},
@@ -550,8 +552,8 @@ class EmbeddingUsage(LLMUsage):
         """
         # check seq length
         max_len = self.embedding_max_sequence_length or configs.embedding.max_sequence_length
-        if max_len and any(len(t) > max_len for t in input_text):
-            logger.error(err := f"Input text exceeds maximum sequence length {max_len}.")
+        if max_len and any(length:=(token_counter(text=t)) > max_len for t in input_text):
+            logger.error(err := f"Input text exceeds maximum sequence length {max_len}, got {length}.")
             raise ValueError(err)
 
         return await litellm.aembedding(