uipath-langchain 0.0.133__py3-none-any.whl → 0.1.28__py3-none-any.whl

uipath_langchain/_cli/cli_run.py

@@ -1,82 +0,0 @@
-import asyncio
-import os
-from typing import Optional
-
-from openinference.instrumentation.langchain import (
-    LangChainInstrumentor,
-    get_current_span,
-)
-from uipath._cli._runtime._contracts import (
-    UiPathRuntimeFactory,
-)
-from uipath._cli.middlewares import MiddlewareResult
-
-from .._tracing import LangChainExporter, _instrument_traceable_attributes
-from ._runtime._exception import LangGraphRuntimeError
-from ._runtime._runtime import (  # type: ignore[attr-defined]
-    LangGraphRuntime,
-    LangGraphRuntimeContext,
-)
-from ._utils._graph import LangGraphConfig
-
-
-def langgraph_run_middleware(
-    entrypoint: Optional[str], input: Optional[str], resume: bool, **kwargs
-) -> MiddlewareResult:
-    """Middleware to handle LangGraph execution"""
-    config = LangGraphConfig()
-    if not config.exists:
-        return MiddlewareResult(
-            should_continue=True
-        )  # Continue with normal flow if no langgraph.json
-
-    try:
-        context = LangGraphRuntimeContext.with_defaults(**kwargs)
-        context.langgraph_config = config
-        context.entrypoint = entrypoint
-        context.input = input
-        context.resume = resume
-
-        _instrument_traceable_attributes()
-
-        def generate_runtime(ctx: LangGraphRuntimeContext) -> LangGraphRuntime:
-            runtime = LangGraphRuntime(ctx)
-            # If not resuming and no job id, delete the previous state file
-            if not ctx.resume and ctx.job_id is None:
-                if os.path.exists(runtime.state_file_path):
-                    os.remove(runtime.state_file_path)
-            return runtime
-
-        async def execute():
-            runtime_factory = UiPathRuntimeFactory(
-                LangGraphRuntime,
-                LangGraphRuntimeContext,
-                runtime_generator=generate_runtime,
-            )
-
-            if context.job_id:
-                runtime_factory.add_span_exporter(LangChainExporter())
-
-            runtime_factory.add_instrumentor(LangChainInstrumentor, get_current_span)
-
-            await runtime_factory.execute(context)
-
-        asyncio.run(execute())
-
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=None,
-        )
-
-    except LangGraphRuntimeError as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=e.error_info.detail,
-            should_include_stacktrace=True,
-        )
-    except Exception as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: {str(e)}",
-            should_include_stacktrace=True,
-        )

uipath_langchain/_tracing/_oteladapter.py

@@ -1,222 +0,0 @@
-import json
-import logging
-from typing import Any, Dict, List
-
-from opentelemetry.sdk.trace.export import (
-    SpanExportResult,
-)
-from uipath.tracing import LlmOpsHttpExporter
-
-logger = logging.getLogger(__name__)
-
-
-def _safe_parse_json(s: Any) -> Any:
-    """Safely parse a JSON string, returning the original if not a string or on error."""
-    if not isinstance(s, str):
-        return s
-    try:
-        return json.loads(s)
-    except (json.JSONDecodeError, TypeError):
-        return s
-
-
-def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str, Any]]:
-    """Extracts and reconstructs LLM messages from flattened attributes."""
-    messages: dict[int, dict[str, Any]] = {}
-    message_prefix = f"{prefix}."
-
-    for key, value in attributes.items():
-        if key.startswith(message_prefix):
-            parts = key[len(message_prefix) :].split(".")
-            if len(parts) >= 2 and parts[0].isdigit():
-                index = int(parts[0])
-                if index not in messages:
-                    messages[index] = {}
-                current: Any = messages[index]
-
-                for i, part in enumerate(parts[1:-1]):
-                    key_part: str | int = part
-                    if part.isdigit() and (
-                        i + 2 < len(parts) and parts[i + 2].isdigit()
-                    ):
-                        key_part = int(part)
-
-                    if isinstance(current, dict):
-                        if key_part not in current:
-                            current[key_part] = {}
-                        current = current[key_part]
-                    elif isinstance(current, list) and isinstance(key_part, int):
-                        if key_part >= len(current):
-                            current.append({})
-                        current = current[key_part]
-
-                current[parts[-1]] = value
-
-    # Convert dict to list, ordered by index
-    return [messages[i] for i in sorted(messages.keys())]
-
-
-class LangChainExporter(LlmOpsHttpExporter):
-    # Mapping of old attribute names to new attribute names or (new name, function)
-    ATTRIBUTE_MAPPING: dict[str, str | tuple[str, Any]] = {
-        "input.value": ("input", _safe_parse_json),
-        "output.value": ("output", _safe_parse_json),
-        "llm.model_name": "model",
-    }
-
-    # Mapping of span types
-    SPAN_TYPE_MAPPING: dict[str, str] = {
-        "LLM": "completion",
-        "TOOL": "toolCall",
-        # Add more mappings as needed
-    }
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
-    def _map_llm_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
-        """Maps attributes for LLM calls, handling flattened keys."""
-        result = attributes.copy()  # Keep original attributes including basic mappings
-
-        # Token Usage
-        token_keys = {
-            "llm.token_count.prompt": "promptTokens",
-            "llm.token_count.completion": "completionTokens",
-            "llm.token_count.total": "totalTokens",
-        }
-        usage = {
-            new_key: attributes.get(old_key)
-            for old_key, new_key in token_keys.items()
-            if old_key in attributes
-        }
-        if usage:
-            result["usage"] = usage
-
-        # Input/Output Messages
-        result["input"] = _get_llm_messages(attributes, "llm.input_messages")
-        output_messages = _get_llm_messages(attributes, "llm.output_messages")
-        result["output"] = output_messages
-
-        # Invocation Parameters
-        invocation_params = _safe_parse_json(
-            attributes.get("llm.invocation_parameters", "{}")
-        )
-        if isinstance(invocation_params, dict):
-            result["model"] = invocation_params.get("model", result.get("model"))
-            settings: dict[str, Any] = {}
-            if "max_tokens" in invocation_params:
-                settings["maxTokens"] = invocation_params["max_tokens"]
-            if "temperature" in invocation_params:
-                settings["temperature"] = invocation_params["temperature"]
-            if settings:
-                result["settings"] = settings
-
-        # Tool Calls
-        tool_calls: list[dict[str, Any]] = []
-        for msg in output_messages:
-            # Ensure msg is a dictionary before proceeding
-            if not isinstance(msg, dict):
-                continue
-            msg_tool_calls = msg.get("message", {}).get("tool_calls", [])
-
-            # Ensure msg_tool_calls is a list
-            if not isinstance(msg_tool_calls, list):
-                continue
-
-            for tc in msg_tool_calls:
-                if not isinstance(tc, dict):
-                    continue
-                tool_call_data = tc.get("tool_call", {})
-                if not isinstance(tool_call_data, dict):
-                    continue
-                tool_calls.append(
-                    {
-                        "id": tool_call_data.get("id"),
-                        "name": tool_call_data.get("function", {}).get("name"),
-                        "arguments": _safe_parse_json(
-                            tool_call_data.get("function", {}).get("arguments", "{}")
-                        ),
-                    }
-                )
-        if tool_calls:
-            result["toolCalls"] = tool_calls
-
-        return result
-
-    def _map_tool_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
-        """Maps attributes for tool calls."""
-        result = attributes.copy()  # Keep original attributes
-
-        result["type"] = "toolCall"
-        result["callId"] = attributes.get("call_id") or attributes.get("id")
-        result["toolName"] = attributes.get("tool.name")
-        result["arguments"] = _safe_parse_json(
-            attributes.get("input", attributes.get("input.value", "{}"))
-        )
-        result["toolType"] = "Integration"
-        result["result"] = _safe_parse_json(
-            attributes.get("output", attributes.get("output.value"))
-        )
-        result["error"] = None
-
-        return result
-
-    def _process_span_attributes(self, span_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extracts, transforms, and maps attributes for a span."""
-        if "Attributes" not in span_data:
-            return span_data
-
-        logger.info(f"Processing span: {span_data}")
-
-        attributes_val = span_data["Attributes"]
-        if isinstance(attributes_val, str):
-            try:
-                attributes: Dict[str, Any] = json.loads(attributes_val)
-            except json.JSONDecodeError as e:
-                logger.warning(f"Failed to parse attributes JSON: {e}")
-                return span_data
-        elif isinstance(attributes_val, dict):
-            attributes = attributes_val
-        else:
-            return span_data
-
-        # Determine SpanType
-        if "openinference.span.kind" in attributes:
-            span_type = attributes["openinference.span.kind"]
-            span_data["SpanType"] = self.SPAN_TYPE_MAPPING.get(span_type, span_type)
-
-        # Apply basic attribute mapping
-        for old_key, mapping in self.ATTRIBUTE_MAPPING.items():
-            if old_key in attributes:
-                if isinstance(mapping, tuple):
-                    new_key, func = mapping
-                    attributes[new_key] = func(attributes[old_key])
-                else:
-                    new_key = mapping
-                    attributes[new_key] = attributes[old_key]
-
-        # Apply detailed mapping based on SpanType
-        span_type = span_data.get("SpanType")
-        if span_type == "completion":
-            processed_attributes = self._map_llm_call_attributes(attributes)
-        elif span_type == "toolCall":
-            processed_attributes = self._map_tool_call_attributes(attributes)
-        else:
-            processed_attributes = attributes.copy()
-
-        span_data["Attributes"] = json.dumps(processed_attributes)
-
-        logger.info(f"Transformed span: {span_data}")
-        return span_data
-
-    def _send_with_retries(
-        self, url: str, payload: List[Dict[str, Any]], max_retries: int = 4
-    ) -> SpanExportResult:
-        # Transform attributes in each span's payload before sending
-        transformed_payload = [self._process_span_attributes(span) for span in payload]
-
-        return super()._send_with_retries(
-            url=url,
-            payload=transformed_payload,
-            max_retries=max_retries,
-        )

uipath_langchain/_tracing/_utils.py

@@ -1,28 +0,0 @@
-import logging
-
-
-class IgnoreSpecificUrl(logging.Filter):
-    def __init__(self, url_to_ignore):
-        super().__init__()
-        self.url_to_ignore = url_to_ignore
-
-    def filter(self, record):
-        try:
-            if record.msg == 'HTTP Request: %s %s "%s %d %s"':
-                # Ignore the log if the URL matches the one we want to ignore
-                method = record.args[0]
-                url = record.args[1]
-
-                if method == "POST" and url.path.endswith(self.url_to_ignore):
-                    # Check if the URL contains the specific path we want to ignore
-                    return True
-                return False
-
-        except Exception:
-            return False
-
-
-def _setup_tracer_httpx_logging(url: str):
-    # Create a custom logger for httpx
-    # Add the custom filter to the root logger
-    logging.getLogger("httpx").addFilter(IgnoreSpecificUrl(url))

uipath_langchain/builder/agent_config.py

@@ -1,191 +0,0 @@
-from enum import Enum
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class AgentMessageRole(str, Enum):
-    """Enum for message roles"""
-
-    SYSTEM = "System"
-    USER = "User"
-
-
-class AgentMessage(BaseModel):
-    """Message model for agent conversations"""
-
-    role: AgentMessageRole
-    content: str
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentSettings(BaseModel):
-    """Settings for agent configuration"""
-
-    engine: str = Field(..., description="Engine type, e.g., 'basic-v1'")
-    model: str = Field(..., description="LLM model identifier")
-    max_tokens: int = Field(
-        ..., alias="maxTokens", description="Maximum number of tokens"
-    )
-    temperature: float = Field(..., description="Temperature for response generation")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentResourceType(str, Enum):
-    """Enum for resource types"""
-
-    TOOL = "tool"
-    CONTEXT = "context"
-    ESCALATION = "escalation"
-
-
-class AgentBaseResourceConfig(BaseModel):
-    """Base resource model with common properties"""
-
-    name: str
-    description: str
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentUnknownResourceConfig(AgentBaseResourceConfig):
-    """Fallback for unknown or future resource types"""
-
-    resource_type: str = Field(alias="$resourceType")
-
-    model_config = ConfigDict(extra="allow")
-
-
-class AgentToolSettings(BaseModel):
-    """Settings for tool configuration"""
-
-    max_attempts: int = Field(0, alias="maxAttempts")
-    retry_delay: int = Field(0, alias="retryDelay")
-    timeout: int = Field(0)
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentToolProperties(BaseModel):
-    """Properties specific to tool configuration"""
-
-    folder_path: Optional[str] = Field(None, alias="folderPath")
-    process_name: Optional[str] = Field(None, alias="processName")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentToolResourceConfig(AgentBaseResourceConfig):
-    """Tool resource with tool-specific properties"""
-
-    resource_type: Literal[AgentResourceType.TOOL] = Field(alias="$resourceType")
-    type: str = Field(..., description="Tool type")
-    arguments: Dict[str, Any] = Field(
-        default_factory=dict, description="Tool arguments"
-    )
-    input_schema: Dict[str, Any] = Field(
-        ..., alias="inputSchema", description="Input schema for the tool"
-    )
-    output_schema: Dict[str, Any] = Field(
-        ..., alias="outputSchema", description="Output schema for the tool"
-    )
-    properties: AgentToolProperties = Field(..., description="Tool-specific properties")
-    settings: AgentToolSettings = Field(
-        default_factory=AgentToolSettings, description="Tool settings"
-    )
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentContextSettings(BaseModel):
-    """Settings for context configuration"""
-
-    result_count: int = Field(alias="resultCount")
-    retrieval_mode: Literal["Semantic", "Structured"] = Field(alias="retrievalMode")
-    threshold: float = Field(default=0)
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentContextResourceConfig(AgentBaseResourceConfig):
-    """Context resource with context-specific properties"""
-
-    resource_type: Literal[AgentResourceType.CONTEXT] = Field(alias="$resourceType")
-    folder_path: str = Field(alias="folderPath")
-    index_name: str = Field(alias="indexName")
-    settings: AgentContextSettings = Field(..., description="Context settings")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-class AgentEscalationResourceConfig(AgentBaseResourceConfig):
-    """Escalation resource with escalation-specific properties"""
-
-    resource_type: Literal[AgentResourceType.ESCALATION] = Field(alias="$resourceType")
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
-# Discriminated union for known types
-KnownAgentResourceConfig = Annotated[
-    Union[
-        AgentToolResourceConfig,
-        AgentContextResourceConfig,
-        AgentEscalationResourceConfig,
-    ],
-    Field(discriminator="resource_type"),
-]
-
-# Final union includes unknowns as a catch-all
-AgentResourceConfig = Union[
-    KnownAgentResourceConfig,
-    AgentUnknownResourceConfig,
-]
-
-
-class AgentConfig(BaseModel):
-    """Main agent model"""
-
-    id: str = Field(..., description="Agent id or project name")
-    name: str = Field(..., description="Agent name or project name")
-    input_schema: Dict[str, Any] = Field(
-        ..., alias="inputSchema", description="JSON schema for input arguments"
-    )
-    output_schema: Dict[str, Any] = Field(
-        ..., alias="outputSchema", description="JSON schema for output arguments"
-    )
-    messages: List[AgentMessage] = Field(
-        ..., description="List of system and user messages"
-    )
-    features: List[Any] = Field(
-        default_factory=list, description="Currently empty feature list"
-    )
-    version: str = Field("1.0.0", description="Agent version")
-    settings: AgentSettings = Field(..., description="Agent settings configuration")
-    resources: List[AgentResourceConfig] = Field(
-        ..., description="List of tools, context, and escalation resources"
-    )
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )