klaude-code 1.2.6__py3-none-any.whl

klaude_code/llm/input_common.py

@@ -0,0 +1,239 @@
+"""Common utilities for converting conversation history to LLM input formats.
+
+This module provides shared abstractions for providers that require message grouping
+(Anthropic, OpenAI-compatible, OpenRouter). The Responses API doesn't need this
+since it uses a flat item list matching our internal protocol.
+"""
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Iterable
+
+from klaude_code import const
+
+if TYPE_CHECKING:
+    from klaude_code.protocol.llm_param import LLMCallParameter, LLMConfigParameter
+
+from klaude_code.protocol import model
+
+
+class GroupKind(Enum):
+    ASSISTANT = "assistant"
+    USER = "user"
+    TOOL = "tool"
+    DEVELOPER = "developer"
+    OTHER = "other"
+
+
+@dataclass
+class UserGroup:
+    """Aggregated user message group (UserMessageItem + DeveloperMessageItem)."""
+
+    text_parts: list[str] = field(default_factory=lambda: [])
+    images: list[model.ImageURLPart] = field(default_factory=lambda: [])
+
+
+@dataclass
+class ToolGroup:
+    """Aggregated tool result group (ToolResultItem + trailing DeveloperMessageItems)."""
+
+    tool_result: model.ToolResultItem
+    reminder_texts: list[str] = field(default_factory=lambda: [])
+    reminder_images: list[model.ImageURLPart] = field(default_factory=lambda: [])
+
+
+@dataclass
+class AssistantGroup:
+    """Aggregated assistant message group."""
+
+    text_content: str | None = None
+    tool_calls: list[model.ToolCallItem] = field(default_factory=lambda: [])
+    reasoning_text: list[model.ReasoningTextItem] = field(default_factory=lambda: [])
+    reasoning_encrypted: list[model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
+    # Preserve original ordering of reasoning items for providers that
+    # need to emit them as an ordered stream (e.g. OpenRouter).
+    reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
+
+
+MessageGroup = UserGroup | ToolGroup | AssistantGroup
+
+
+def _kind_of(item: model.ConversationItem) -> GroupKind:
+    if isinstance(
+        item,
+        (model.ReasoningTextItem, model.ReasoningEncryptedItem, model.AssistantMessageItem, model.ToolCallItem),
+    ):
+        return GroupKind.ASSISTANT
+    if isinstance(item, model.UserMessageItem):
+        return GroupKind.USER
+    if isinstance(item, model.ToolResultItem):
+        return GroupKind.TOOL
+    if isinstance(item, model.DeveloperMessageItem):
+        return GroupKind.DEVELOPER
+    return GroupKind.OTHER
+
+
+def group_response_items_gen(
+    items: Iterable[model.ConversationItem],
+) -> Iterator[tuple[GroupKind, list[model.ConversationItem]]]:
+    """Group response items into sublists with predictable attachment rules.
+
+    - Consecutive assistant-side items (ReasoningTextItem | ReasoningEncryptedItem |
+      AssistantMessageItem | ToolCallItem) group together.
+    - Consecutive UserMessage group together.
+    - Each ToolMessage (ToolResultItem) is a single group, but allow following
+      DeveloperMessage to attach to it.
+    - DeveloperMessage only attaches to the previous UserMessage/ToolMessage group.
+    """
+    buffer: list[model.ConversationItem] = []
+    buffer_kind: GroupKind | None = None
+
+    def flush() -> Iterator[tuple[GroupKind, list[model.ConversationItem]]]:
+        """Yield current group and reset buffer state."""
+
+        nonlocal buffer, buffer_kind
+        if buffer_kind is not None and buffer:
+            yield (buffer_kind, buffer)
+        buffer = []
+        buffer_kind = None
+
+    for item in items:
+        item_kind = _kind_of(item)
+        if item_kind == GroupKind.OTHER:
+            continue
+
+        # Developer messages only attach to existing user/tool group.
+        if item_kind == GroupKind.DEVELOPER:
+            if buffer_kind in (GroupKind.USER, GroupKind.TOOL):
+                buffer.append(item)
+            continue
+
+        # Start a new group when there is no active buffer yet.
+        if buffer_kind is None:
+            buffer_kind = GroupKind.TOOL if item_kind == GroupKind.TOOL else item_kind
+            buffer = [item]
+            continue
+
+        # Tool messages always form a standalone group.
+        if item_kind == GroupKind.TOOL:
+            yield from flush()
+            buffer_kind = GroupKind.TOOL
+            buffer = [item]
+            continue
+
+        # Same non-tool kind: extend current group.
+        if item_kind == buffer_kind:
+            buffer.append(item)
+            continue
+
+        # Different non-tool kind: close previous group and start a new one.
+        yield from flush()
+        buffer_kind = item_kind
+        buffer = [item]
+
+    if buffer_kind is not None and buffer:
+        yield (buffer_kind, buffer)
+
+
+def parse_message_groups(history: list[model.ConversationItem]) -> list[MessageGroup]:
+    """Parse conversation history into aggregated message groups.
+
+    This is the shared grouping logic for Anthropic, OpenAI-compatible, and OpenRouter.
+    Each provider then converts these groups to their specific API format.
+    """
+    groups: list[MessageGroup] = []
+
+    for kind, items in group_response_items_gen(history):
+        match kind:
+            case GroupKind.OTHER:
+                continue
+            case GroupKind.USER:
+                group = UserGroup()
+                for item in items:
+                    if isinstance(item, (model.UserMessageItem, model.DeveloperMessageItem)):
+                        if item.content:
+                            group.text_parts.append(item.content)
+                        if item.images:
+                            group.images.extend(item.images)
+                groups.append(group)
+
+            case GroupKind.TOOL:
+                if not items or not isinstance(items[0], model.ToolResultItem):
+                    continue
+                tool_result = items[0]
+                group = ToolGroup(tool_result=tool_result)
+                for item in items[1:]:
+                    if isinstance(item, model.DeveloperMessageItem):
+                        if item.content:
+                            group.reminder_texts.append(item.content)
+                        if item.images:
+                            group.reminder_images.extend(item.images)
+                groups.append(group)
+
+            case GroupKind.ASSISTANT:
+                group = AssistantGroup()
+                for item in items:
+                    match item:
+                        case model.AssistantMessageItem():
+                            if item.content:
+                                if group.text_content is None:
+                                    group.text_content = item.content
+                                else:
+                                    group.text_content += item.content
+                        case model.ToolCallItem():
+                            group.tool_calls.append(item)
+                        case model.ReasoningTextItem():
+                            group.reasoning_text.append(item)
+                            group.reasoning_items.append(item)
+                        case model.ReasoningEncryptedItem():
+                            group.reasoning_encrypted.append(item)
+                            group.reasoning_items.append(item)
+                        case _:
+                            pass
+                groups.append(group)
+
+            case GroupKind.DEVELOPER:
+                pass
+
+    return groups
+
+
+def merge_reminder_text(tool_output: str | None, reminder_texts: list[str]) -> str:
+    """Merge tool output with reminder texts."""
+    base = tool_output or ""
+    if reminder_texts:
+        base += "\n" + "\n".join(reminder_texts)
+    return base
+
+
+def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter") -> "LLMCallParameter":
+    """Apply config defaults to LLM call parameters."""
+    if param.model is None:
+        param.model = config.model
+    if param.temperature is None:
+        param.temperature = config.temperature
+    if param.max_tokens is None:
+        param.max_tokens = config.max_tokens
+    if param.context_limit is None:
+        param.context_limit = config.context_limit
+    if param.verbosity is None:
+        param.verbosity = config.verbosity
+    if param.thinking is None:
+        param.thinking = config.thinking
+    if param.provider_routing is None:
+        param.provider_routing = config.provider_routing
+
+    if param.model is None:
+        raise ValueError("Model is required")
+    if param.max_tokens is None:
+        param.max_tokens = const.DEFAULT_MAX_TOKENS
+    if param.temperature is None:
+        param.temperature = const.DEFAULT_TEMPERATURE
+    if param.thinking is not None and param.thinking.type == "enabled" and param.thinking.budget_tokens is None:
+        param.thinking.budget_tokens = const.DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS
+
+    if param.model and "gpt-5" in param.model:
+        param.temperature = 1.0  # Required for GPT-5
+
+    return param

klaude_code/llm/openai_compatible/__init__.py

@@ -0,0 +1,3 @@
+from .client import OpenAICompatibleClient
+
+__all__ = ["OpenAICompatibleClient"]

klaude_code/llm/openai_compatible/client.py

@@ -0,0 +1,211 @@
+import json
+from collections.abc import AsyncGenerator
+from typing import Literal, override
+
+import httpx
+import openai
+from openai import APIError, RateLimitError
+
+from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
+from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.openai_compatible.input import convert_history_to_input, convert_tool_schema
+from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
+from klaude_code.llm.registry import register
+from klaude_code.llm.usage import MetadataTracker, convert_usage
+from klaude_code.protocol import llm_param, model
+from klaude_code.trace import DebugType, log_debug
+
+
+@register(llm_param.LLMClientProtocol.OPENAI)
+class OpenAICompatibleClient(LLMClientABC):
+    def __init__(self, config: llm_param.LLMConfigParameter):
+        super().__init__(config)
+        if config.is_azure:
+            if not config.base_url:
+                raise ValueError("Azure endpoint is required")
+            client = openai.AsyncAzureOpenAI(
+                api_key=config.api_key,
+                azure_endpoint=str(config.base_url),
+                api_version=config.azure_api_version,
+                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+            )
+        else:
+            client = openai.AsyncOpenAI(
+                api_key=config.api_key,
+                base_url=config.base_url,
+                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+            )
+        self.client: openai.AsyncAzureOpenAI | openai.AsyncOpenAI = client
+
+    @classmethod
+    @override
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+        return cls(config)
+
+    @override
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+        param = apply_config_defaults(param, self.get_llm_config())
+        messages = convert_history_to_input(param.input, param.system, param.model)
+        tools = convert_tool_schema(param.tools)
+
+        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+
+        extra_body = {}
+        extra_headers = {"extra": json.dumps({"session_id": param.session_id})}
+
+        if param.thinking:
+            extra_body["thinking"] = {
+                "type": param.thinking.type,
+                "budget": param.thinking.budget_tokens,
+            }
+        stream = call_with_logged_payload(
+            self.client.chat.completions.create,
+            model=str(param.model),
+            tool_choice="auto",
+            parallel_tool_calls=True,
+            stream=True,
+            messages=messages,
+            temperature=param.temperature,
+            max_tokens=param.max_tokens,
+            tools=tools,
+            reasoning_effort=param.thinking.reasoning_effort if param.thinking else None,
+            verbosity=param.verbosity,
+            extra_body=extra_body,  # pyright: ignore[reportUnknownArgumentType]
+            extra_headers=extra_headers,
+        )
+
+        stage: Literal["waiting", "reasoning", "assistant", "tool", "done"] = "waiting"
+        accumulated_reasoning: list[str] = []
+        accumulated_content: list[str] = []
+        accumulated_tool_calls: ToolCallAccumulatorABC = BasicToolCallAccumulator()
+        emitted_tool_start_indices: set[int] = set()
+        response_id: str | None = None
+
+        def flush_reasoning_items() -> list[model.ConversationItem]:
+            nonlocal accumulated_reasoning
+            if not accumulated_reasoning:
+                return []
+            item = model.ReasoningTextItem(
+                content="".join(accumulated_reasoning),
+                response_id=response_id,
+                model=str(param.model),
+            )
+            accumulated_reasoning = []
+            return [item]
+
+        def flush_assistant_items() -> list[model.ConversationItem]:
+            nonlocal accumulated_content
+            if len(accumulated_content) == 0:
+                return []
+            item = model.AssistantMessageItem(
+                content="".join(accumulated_content),
+                response_id=response_id,
+            )
+            accumulated_content = []
+            return [item]
+
+        def flush_tool_call_items() -> list[model.ToolCallItem]:
+            nonlocal accumulated_tool_calls
+            items: list[model.ToolCallItem] = accumulated_tool_calls.get()
+            if items:
+                accumulated_tool_calls.chunks_by_step = []  # pyright: ignore[reportAttributeAccessIssue]
+            return items
+
+        try:
+            async for event in await stream:
+                log_debug(
+                    event.model_dump_json(exclude_none=True),
+                    style="blue",
+                    debug_type=DebugType.LLM_STREAM,
+                )
+                if not response_id and event.id:
+                    response_id = event.id
+                    accumulated_tool_calls.response_id = response_id
+                    yield model.StartItem(response_id=response_id)
+                if (
+                    event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison] gcp gemini will return None usage field
+                ):
+                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
+                if event.model:
+                    metadata_tracker.set_model_name(event.model)
+                if provider := getattr(event, "provider", None):
+                    metadata_tracker.set_provider(str(provider))
+
+                if len(event.choices) == 0:
+                    continue
+                delta = event.choices[0].delta
+
+                # Support Kimi K2's usage field in choice
+                if hasattr(event.choices[0], "usage") and getattr(event.choices[0], "usage"):
+                    metadata_tracker.set_usage(
+                        convert_usage(
+                            openai.types.CompletionUsage.model_validate(getattr(event.choices[0], "usage")),
+                            param.context_limit,
+                        )
+                    )
+
+                # Reasoning
+                reasoning_content = ""
+                if hasattr(delta, "reasoning") and getattr(delta, "reasoning"):
+                    reasoning_content = getattr(delta, "reasoning")
+                if hasattr(delta, "reasoning_content") and getattr(delta, "reasoning_content"):
+                    reasoning_content = getattr(delta, "reasoning_content")
+                if reasoning_content:
+                    metadata_tracker.record_token()
+                    stage = "reasoning"
+                    accumulated_reasoning.append(reasoning_content)
+
+                # Assistant
+                if delta.content and (
+                    stage == "assistant" or delta.content.strip()
+                ):  # Process all content in assistant stage, filter empty content in reasoning stage
+                    metadata_tracker.record_token()
+                    if stage == "reasoning":
+                        for item in flush_reasoning_items():
+                            yield item
+                    elif stage == "tool":
+                        for item in flush_tool_call_items():
+                            yield item
+                    stage = "assistant"
+                    accumulated_content.append(delta.content)
+                    yield model.AssistantMessageDelta(
+                        content=delta.content,
+                        response_id=response_id,
+                    )
+
+                # Tool
+                if delta.tool_calls and len(delta.tool_calls) > 0:
+                    metadata_tracker.record_token()
+                    if stage == "reasoning":
+                        for item in flush_reasoning_items():
+                            yield item
+                    elif stage == "assistant":
+                        for item in flush_assistant_items():
+                            yield item
+                    stage = "tool"
+                    # Emit ToolCallStartItem for new tool calls
+                    for tc in delta.tool_calls:
+                        if tc.index not in emitted_tool_start_indices and tc.function and tc.function.name:
+                            emitted_tool_start_indices.add(tc.index)
+                            yield model.ToolCallStartItem(
+                                response_id=response_id,
+                                call_id=tc.id or "",
+                                name=tc.function.name,
+                            )
+                    accumulated_tool_calls.add(delta.tool_calls)
+        except (RateLimitError, APIError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+
+        # Finalize
+        for item in flush_reasoning_items():
+            yield item
+
+        for item in flush_assistant_items():
+            yield item
+
+        if stage == "tool":
+            for tool_call_item in flush_tool_call_items():
+                yield tool_call_item
+
+        metadata_tracker.set_response_id(response_id)
+        yield metadata_tracker.finalize()

klaude_code/llm/openai_compatible/input.py

@@ -0,0 +1,109 @@
+# pyright: reportReturnType=false
+# pyright: reportArgumentType=false
+# pyright: reportUnknownMemberType=false
+# pyright: reportAttributeAccessIssue=false
+
+from openai.types import chat
+from openai.types.chat import ChatCompletionContentPartParam
+
+from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, merge_reminder_text, parse_message_groups
+from klaude_code.protocol import llm_param, model
+
+
+def _user_group_to_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
+    parts: list[ChatCompletionContentPartParam] = []
+    for text in group.text_parts:
+        parts.append({"type": "text", "text": text + "\n"})
+    for image in group.images:
+        parts.append({"type": "image_url", "image_url": {"url": image.image_url.url}})
+    if not parts:
+        parts.append({"type": "text", "text": ""})
+    return {"role": "user", "content": parts}
+
+
+def _tool_group_to_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
+    merged_text = merge_reminder_text(
+        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
+        group.reminder_texts,
+    )
+    return {
+        "role": "tool",
+        "content": [{"type": "text", "text": merged_text}],
+        "tool_call_id": group.tool_result.call_id,
+    }
+
+
+def _assistant_group_to_message(
+    group: AssistantGroup,
+) -> chat.ChatCompletionMessageParam:
+    assistant_message: dict[str, object] = {"role": "assistant"}
+
+    if group.text_content:
+        assistant_message["content"] = group.text_content
+
+    if group.tool_calls:
+        assistant_message["tool_calls"] = [
+            {
+                "id": tc.call_id,
+                "type": "function",
+                "function": {
+                    "name": tc.name,
+                    "arguments": tc.arguments,
+                },
+            }
+            for tc in group.tool_calls
+        ]
+
+    return assistant_message
+
+
+def build_user_content_parts(
+    images: list[model.ImageURLPart],
+) -> list[ChatCompletionContentPartParam]:
+    """Build content parts for images only. Used by OpenRouter."""
+    return [{"type": "image_url", "image_url": {"url": image.image_url.url}} for image in images]
+
+
+def convert_history_to_input(
+    history: list[model.ConversationItem],
+    system: str | None = None,
+    model_name: str | None = None,
+) -> list[chat.ChatCompletionMessageParam]:
+    """
+    Convert a list of conversation items to a list of chat completion message params.
+
+    Args:
+        history: List of conversation items.
+        system: System message.
+        model_name: Model name. Not used in OpenAI-compatible, kept for API consistency.
+    """
+    messages: list[chat.ChatCompletionMessageParam] = [{"role": "system", "content": system}] if system else []
+
+    for group in parse_message_groups(history):
+        match group:
+            case UserGroup():
+                messages.append(_user_group_to_message(group))
+            case ToolGroup():
+                messages.append(_tool_group_to_message(group))
+            case AssistantGroup():
+                messages.append(_assistant_group_to_message(group))
+
+    return messages
+
+
+def convert_tool_schema(
+    tools: list[llm_param.ToolSchema] | None,
+) -> list[chat.ChatCompletionToolParam]:
+    if tools is None:
+        return []
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.parameters,
+            },
+        }
+        for tool in tools
+    ]

klaude_code/llm/openai_compatible/tool_call_accumulator.py

@@ -0,0 +1,80 @@
+from abc import ABC, abstractmethod
+
+from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
+from pydantic import BaseModel, Field
+
+from klaude_code.protocol import model
+
+
+class ToolCallAccumulatorABC(ABC):
+    @abstractmethod
+    def add(self, chunks: list[ChoiceDeltaToolCall]) -> None:
+        pass
+
+    @abstractmethod
+    def get(self) -> list[model.ToolCallItem]:
+        pass
+
+
+class BasicToolCallAccumulator(ToolCallAccumulatorABC, BaseModel):
+    """
+    Support for API:
+    - returns multiple tool calls within a single response in a serial manner.
+    - Each step contains exactly one chunk.
+
+    e.g.:
+    Claude, GPT series
+    The sequence for each tool call follows this pattern:
+    - Initial chunk: contains tool call id and function name
+    - Subsequent chunks: contain argument fragments with id and name set to None
+    - Every chunk has a valid index
+    - Pattern repeats for the next tool call
+    [ChoiceDeltaToolCall(index=0, id='toolu_vrtx_01QxTq6QeJZd9tTLt6pvtSy6', function=ChoiceDeltaToolCallFunction(arguments='', name='Bash'), type='function')]
+    [ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='{"comm', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='an', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='d": "', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=0, id=None, function=ChoiceDeltaToolCallFunction(arguments='pwd"}', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=1, id='toolu_vrtx_01Uvxge2edYAZBnNLoYGeDBg', function=ChoiceDeltaToolCallFunction(arguments='', name='Bash'), type='function')]
+    [ChoiceDeltaToolCall(index=1, id=None, function=ChoiceDeltaToolCallFunction(arguments='', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=1, id=None, function=ChoiceDeltaToolCallFunction(arguments='{"com', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=1, id=None, function=ChoiceDeltaToolCallFunction(arguments='mand":', name=None), type='function')]
+    [ChoiceDeltaToolCall(index=1, id=None, function=ChoiceDeltaToolCallFunction(arguments=' "ls"}', name=None), type='function')]
+
+    Grok, Gemini
+    Each step is one completed tool call
+    [ChoiceDeltaToolCall(index=0, id='call_83297568', function=ChoiceDeltaToolCallFunction(arguments='{"command":"pwd"}', name='Bash'), type='function')]
+    [ChoiceDeltaToolCall(index=1, id='call_88931225', function=ChoiceDeltaToolCallFunction(arguments='{"command":"ls"}', name='Bash'), type='function')]
+    """
+
+    chunks_by_step: list[list[ChoiceDeltaToolCall]] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
+    response_id: str | None = None
+
+    def add(self, chunks: list[ChoiceDeltaToolCall]) -> None:
+        self.chunks_by_step.append(chunks)
+
+    def get(self) -> list[model.ToolCallItem]:
+        result: list[model.ToolCallItem] = []
+        current_index = -1
+        for current_step in self.chunks_by_step:
+            if len(current_step) == 0:
+                continue
+            first_chunk = current_step[0]
+            if first_chunk.index != current_index:
+                current_index = first_chunk.index
+                result.append(
+                    model.ToolCallItem(
+                        id=first_chunk.id,
+                        name="",
+                        arguments="",
+                        call_id=first_chunk.id or "",
+                        response_id=self.response_id,
+                    )
+                )
+            if first_chunk.function is None:
+                continue
+            if first_chunk.function.name:
+                result[-1].name = first_chunk.function.name
+            if first_chunk.function.arguments:
+                result[-1].arguments += first_chunk.function.arguments
+        return result

klaude_code/llm/openrouter/__init__.py

@@ -0,0 +1,3 @@
+from .client import OpenRouterClient
+
+__all__ = ["OpenRouterClient"]