`injector`¶

Full name: tenets.core.instiller.injector

injector¶

Tenet injection system.

This module handles the strategic injection of tenets into generated context to maintain consistency across AI interactions.

Classes¶

InjectionPosition¶

Bases: Enum

Where to inject tenets in the context.

InjectionPoint`dataclass`¶

Python

InjectionPoint(position: int, score: float, reason: str, after_section: Optional[str] = None)

A specific point where a tenet can be injected.

TenetInjector¶

Python

TenetInjector(config: Optional[Dict[str, Any]] = None)

Handles strategic injection of tenets into context.

Initialize the injector.

PARAMETER	DESCRIPTION
`config`	Injection configuration TYPE:`Optional[Dict[str, Any]]`DEFAULT:`None`

Source code in tenets/core/instiller/injector.py

Python

def __init__(self, config: Optional[Dict[str, Any]] = None):
    """Initialize the injector.

    Args:
        config: Injection configuration
    """
    self.config = config or {}
    self.logger = get_logger(__name__)

    # Injection settings
    self.min_distance_between = self.config.get("min_distance_between", 1000)
    self.prefer_natural_breaks = self.config.get("prefer_natural_breaks", True)
    self.reinforce_at_end = self.config.get("reinforce_at_end", True)

Functions¶

inject_tenets¶

Python

inject_tenets(content: str, tenets: List[Tenet], format: str = 'markdown', context_metadata: Optional[Dict[str, Any]] = None) -> Tuple[str, Dict[str, Any]]

Inject tenets into content.

PARAMETER	DESCRIPTION
`content`	The content to inject into TYPE:`str`
`tenets`	List of tenets to inject TYPE:`List[Tenet]`
`format`	Content format (markdown, xml, json) TYPE:`str`DEFAULT:`'markdown'`
`context_metadata`	Metadata about the context TYPE:`Optional[Dict[str, Any]]`DEFAULT:`None`

RETURNS	DESCRIPTION
`Tuple[str, Dict[str, Any]]`	Tuple of (modified content, injection metadata)

Source code in tenets/core/instiller/injector.py

Python

def inject_tenets(
    self,
    content: str,
    tenets: List[Tenet],
    format: str = "markdown",
    context_metadata: Optional[Dict[str, Any]] = None,
) -> Tuple[str, Dict[str, Any]]:
    """Inject tenets into content.

    Args:
        content: The content to inject into
        tenets: List of tenets to inject
        format: Content format (markdown, xml, json)
        context_metadata: Metadata about the context

    Returns:
        Tuple of (modified content, injection metadata)
    """
    if not tenets:
        return content, {"injected_count": 0}

    # Analyze content structure
    structure = self._analyze_content_structure(content, format)

    # Determine injection strategy
    strategy = self._determine_strategy(
        content_length=len(content), tenet_count=len(tenets), structure=structure
    )

    # Find injection points
    injection_points = self._find_injection_points(
        content=content, structure=structure, strategy=strategy, tenet_count=len(tenets)
    )

    # Sort tenets by priority
    sorted_tenets = sorted(
        tenets, key=lambda t: (t.priority.weight, t.metrics.reinforcement_needed), reverse=True
    )

    # Inject tenets
    injected_content = content
    injection_map = []

    for i, (tenet, point) in enumerate(zip(sorted_tenets, injection_points)):
        # Format tenet for injection
        formatted_tenet = self._format_tenet(tenet, format, position=i)

        # Calculate actual position (accounting for previous injections)
        offset = sum(len(inj["content"]) for inj in injection_map)
        actual_position = point.position + offset

        # Inject
        injected_content = (
            injected_content[:actual_position]
            + formatted_tenet
            + injected_content[actual_position:]
        )

        # Track injection
        injection_map.append(
            {
                "tenet_id": tenet.id,
                "position": actual_position,
                "content": formatted_tenet,
                "reason": point.reason,
            }
        )

    # Add reinforcement section if needed
    if self.reinforce_at_end and len(sorted_tenets) > 3:
        reinforcement = self._create_reinforcement_section(
            sorted_tenets[:3],
            format,  # Top 3 most important
        )
        injected_content += f"\n\n{reinforcement}"

    # Build metadata
    metadata = {
        "injected_count": len(injection_map),
        "strategy": strategy.value,
        "injections": injection_map,
        "token_increase": count_tokens(injected_content) - count_tokens(content),
        "reinforcement_added": self.reinforce_at_end and len(sorted_tenets) > 3,
    }

    return injected_content, metadata

calculate_optimal_injection_count¶

Python

calculate_optimal_injection_count(content_length: int, available_tenets: int, max_token_increase: int = 1000) -> int

Calculate optimal number of tenets to inject.

PARAMETER	DESCRIPTION
`content_length`	Current content length TYPE:`int`
`available_tenets`	Number of available tenets TYPE:`int`
`max_token_increase`	Maximum allowed token increase TYPE:`int`DEFAULT:`1000`

RETURNS	DESCRIPTION
`int`	Optimal number of tenets to inject

Source code in tenets/core/instiller/injector.py

Python

def calculate_optimal_injection_count(
    self, content_length: int, available_tenets: int, max_token_increase: int = 1000
) -> int:
    """Calculate optimal number of tenets to inject.

    Args:
        content_length: Current content length
        available_tenets: Number of available tenets
        max_token_increase: Maximum allowed token increase

    Returns:
        Optimal number of tenets to inject
    """
    # Estimate tokens per tenet (including formatting)
    avg_tenet_tokens = 30

    # Calculate based on content length
    if content_length < 1000:
        base_count = 1
    elif content_length < 5000:
        base_count = 2
    elif content_length < 20000:
        base_count = 3
    elif content_length < 50000:
        base_count = 5
    else:
        base_count = 7

    # Limit by token budget
    max_by_tokens = max_token_increase // avg_tenet_tokens

    # Take minimum of all constraints
    return min(base_count, available_tenets, max_by_tokens)

inject_into_context_result¶

Python

inject_into_context_result(context_result: ContextResult, tenets: List[Tenet]) -> ContextResult

Inject tenets into a ContextResult object.

PARAMETER	DESCRIPTION
`context_result`	The context result to modify TYPE:`ContextResult`
`tenets`	Tenets to inject TYPE:`List[Tenet]`

RETURNS	DESCRIPTION
`ContextResult`	Modified context result

Source code in tenets/core/instiller/injector.py

Python

def inject_into_context_result(
    self, context_result: ContextResult, tenets: List[Tenet]
) -> ContextResult:
    """Inject tenets into a ContextResult object.

    Args:
        context_result: The context result to modify
        tenets: Tenets to inject

    Returns:
        Modified context result
    """
    # Inject into the context content
    modified_content, injection_metadata = self.inject_tenets(
        content=context_result.context,
        tenets=tenets,
        format=context_result.format,
        context_metadata=context_result.metadata,
    )

    # Update the context result
    context_result.context = modified_content

    # Update metadata
    context_result.metadata["tenet_injection"] = injection_metadata
    context_result.metadata["tenets_injected"] = [
        {"id": t.id, "content": t.content, "priority": t.priority.value} for t in tenets
    ]

    # Update token count if available
    if "total_tokens" in context_result.metadata:
        context_result.metadata["total_tokens"] += injection_metadata["token_increase"]

    return context_result

injector¶

injector¶

Classes¶

InjectionPosition¶

InjectionPointdataclass¶

TenetInjector¶

Functions¶

inject_tenets¶

calculate_optimal_injection_count¶

inject_into_context_result¶

Functions¶

`injector`¶

InjectionPoint`dataclass`¶