uipath-langchain 0.0.124__py3-none-any.whl → 0.0.126__py3-none-any.whl

uipath_langchain/_cli/_runtime/_conversation.py

@@ -0,0 +1,256 @@
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    HumanMessage,
+    ToolMessage,
+)
+from uipath.agent.conversation import (
+    UiPathConversationContentPartChunkEvent,
+    UiPathConversationContentPartEndEvent,
+    UiPathConversationContentPartEvent,
+    UiPathConversationContentPartStartEvent,
+    UiPathConversationEvent,
+    UiPathConversationExchangeEvent,
+    UiPathConversationMessageEndEvent,
+    UiPathConversationMessageEvent,
+    UiPathConversationMessageStartEvent,
+    UiPathConversationToolCallEndEvent,
+    UiPathConversationToolCallEvent,
+    UiPathConversationToolCallStartEvent,
+    UiPathInlineValue,
+)
+
+
+def _new_id() -> str:
+    return str(uuid.uuid4())
+
+
+def _wrap_in_conversation_event(
+    msg_event: UiPathConversationMessageEvent,
+    exchange_id: Optional[str] = None,
+    conversation_id: Optional[str] = None,
+) -> UiPathConversationEvent:
+    """Helper to wrap a message event into a conversation-level event."""
+    return UiPathConversationEvent(
+        conversation_id=conversation_id or _new_id(),
+        exchange=UiPathConversationExchangeEvent(
+            exchange_id=exchange_id or _new_id(),
+            message=msg_event,
+        ),
+    )
+
+
+def _extract_text(content) -> str:
+    """Normalize LangGraph message.content to plain text."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "".join(
+            part.get("text", "")
+            for part in content
+            if isinstance(part, dict) and part.get("type") == "text"
+        )
+    return str(content or "")
+
+
+def map_message(
+    message: BaseMessage,
+    exchange_id: Optional[str] = None,
+    conversation_id: Optional[str] = None,
+) -> Optional[UiPathConversationEvent]:
+    """Convert LangGraph BaseMessage (chunk or full) into a UiPathConversationEvent."""
+    message_id = getattr(message, "id", None) or _new_id()
+    timestamp = datetime.now().isoformat()
+
+    # --- Streaming AIMessageChunk ---
+    if isinstance(message, AIMessageChunk):
+        msg_event = UiPathConversationMessageEvent(
+            message_id=message.id or _new_id(),
+        )
+
+        if message.content == []:
+            msg_event.start = UiPathConversationMessageStartEvent(
+                role="assistant", timestamp=timestamp
+            )
+            msg_event.content_part = UiPathConversationContentPartEvent(
+                content_part_id=f"chunk-{message.id}-{0}",
+                start=UiPathConversationContentPartStartEvent(mime_type="text/plain"),
+            )
+
+        elif isinstance(message.content, list) and message.content:
+            for chunk in message.content:
+                if not isinstance(chunk, dict):
+                    continue
+                idx = chunk.get("index", 0)
+                ctype = chunk.get("type")
+                id = chunk.get("id", f"chunk-{message.id}-{idx}")
+
+                # Start of a tool call
+                if ctype == "tool_use":
+                    msg_event.tool_call = UiPathConversationToolCallEvent(
+                        tool_call_id=id,
+                        start=UiPathConversationToolCallStartEvent(
+                            tool_name=chunk.get("name") or "",
+                            arguments=UiPathInlineValue(inline=""),
+                            timestamp=timestamp,
+                        ),
+                    )
+
+                # JSON args streaming (content part for tool args)
+                elif ctype == "input_json_delta":
+                    text = chunk.get("partial_json", "")
+                    # first delta: emit content part start + first chunk
+                    if text == "":
+                        msg_event.content_part = UiPathConversationContentPartEvent(
+                            content_part_id=id,
+                            start=UiPathConversationContentPartStartEvent(
+                                mime_type="application/json"
+                            ),
+                        )
+                    else:
+                        msg_event.content_part = UiPathConversationContentPartEvent(
+                            content_part_id=id,
+                            chunk=UiPathConversationContentPartChunkEvent(
+                                data=text,
+                                content_part_sequence=idx,
+                            ),
+                        )
+
+                # Plain text from assistant
+                elif ctype == "text":
+                    text = chunk.get("text", "")
+                    msg_event.content_part = UiPathConversationContentPartEvent(
+                        content_part_id=id,
+                        chunk=UiPathConversationContentPartChunkEvent(
+                            data=text,
+                            content_part_sequence=idx,
+                        ),
+                    )
+
+        stop_reason = message.response_metadata.get("stop_reason")
+        if not message.content and stop_reason in ("tool_use", "end_turn"):
+            msg_event.end = UiPathConversationMessageEndEvent(timestamp=timestamp)
+
+        if (
+            msg_event.start
+            or msg_event.content_part
+            or msg_event.tool_call
+            or msg_event.end
+        ):
+            return _wrap_in_conversation_event(msg_event, exchange_id, conversation_id)
+
+        return None
+
+    text_content = _extract_text(message.content)
+
+    # --- HumanMessage ---
+    if isinstance(message, HumanMessage):
+        return _wrap_in_conversation_event(
+            UiPathConversationMessageEvent(
+                message_id=message_id,
+                start=UiPathConversationMessageStartEvent(
+                    role="user", timestamp=timestamp
+                ),
+                content_part=UiPathConversationContentPartEvent(
+                    content_part_id=f"cp-{message_id}",
+                    start=UiPathConversationContentPartStartEvent(
+                        mime_type="text/plain"
+                    ),
+                    chunk=UiPathConversationContentPartChunkEvent(data=text_content),
+                    end=UiPathConversationContentPartEndEvent(),
+                ),
+                end=UiPathConversationMessageEndEvent(),
+            ),
+            exchange_id,
+            conversation_id,
+        )
+
+    # --- AIMessage ---
+    if isinstance(message, AIMessage):
+        # Extract first tool call if present
+        tool_calls = getattr(message, "tool_calls", []) or []
+        first_tc = tool_calls[0] if tool_calls else None
+
+        return _wrap_in_conversation_event(
+            UiPathConversationMessageEvent(
+                message_id=message_id,
+                start=UiPathConversationMessageStartEvent(
+                    role="assistant", timestamp=timestamp
+                ),
+                content_part=(
+                    UiPathConversationContentPartEvent(
+                        content_part_id=f"cp-{message_id}",
+                        start=UiPathConversationContentPartStartEvent(
+                            mime_type="text/plain"
+                        ),
+                        chunk=UiPathConversationContentPartChunkEvent(
+                            data=text_content
+                        ),
+                        end=UiPathConversationContentPartEndEvent(),
+                    )
+                    if text_content
+                    else None
+                ),
+                tool_call=(
+                    UiPathConversationToolCallEvent(
+                        tool_call_id=first_tc.get("id") or _new_id(),
+                        start=UiPathConversationToolCallStartEvent(
+                            tool_name=first_tc.get("name"),
+                            arguments=UiPathInlineValue(
+                                inline=str(first_tc.get("args", ""))
+                            ),
+                            timestamp=timestamp,
+                        ),
+                    )
+                    if first_tc
+                    else None
+                ),
+                end=UiPathConversationMessageEndEvent(),
+            ),
+            exchange_id,
+            conversation_id,
+        )
+
+    # --- ToolMessage ---
+    if isinstance(message, ToolMessage):
+        return _wrap_in_conversation_event(
+            UiPathConversationMessageEvent(
+                message_id=message_id,
+                tool_call=UiPathConversationToolCallEvent(
+                    tool_call_id=message.tool_call_id,
+                    start=UiPathConversationToolCallStartEvent(
+                        tool_name=message.name or "",
+                        arguments=UiPathInlineValue(inline=""),
+                        timestamp=timestamp,
+                    ),
+                    end=UiPathConversationToolCallEndEvent(
+                        timestamp=timestamp,
+                        result=UiPathInlineValue(inline=message.content),
+                    ),
+                ),
+            ),
+            exchange_id,
+            conversation_id,
+        )
+
+    # --- Fallback ---
+    return _wrap_in_conversation_event(
+        UiPathConversationMessageEvent(
+            message_id=message_id,
+            start=UiPathConversationMessageStartEvent(
+                role="assistant", timestamp=timestamp
+            ),
+            content_part=UiPathConversationContentPartEvent(
+                content_part_id=f"cp-{message_id}",
+                chunk=UiPathConversationContentPartChunkEvent(data=text_content),
+            ),
+            end=UiPathConversationMessageEndEvent(),
+        ),
+        exchange_id,
+        conversation_id,
+    )

uipath_langchain/_cli/_runtime/_runtime.py

@@ -20,6 +20,7 @@ from ..._utils import _instrument_traceable_attributes
 from ...tracers import AsyncUiPathTracer
 from .._utils._graph import LangGraphConfig
 from ._context import LangGraphRuntimeContext
+from ._conversation import map_message
 from ._exception import LangGraphRuntimeError
 from ._input import LangGraphInputProcessor
 from ._output import LangGraphOutputProcessor
@@ -57,11 +58,6 @@ class LangGraphRuntime(UiPathBaseRuntime):
         tracer = None
 
         try:
-            if self.context.resume is False and self.context.job_id is None:
-                # Delete the previous graph state file at debug time
-                if os.path.exists(self.state_file_path):
-                    os.remove(self.state_file_path)
-
             async with AsyncSqliteSaver.from_conn_string(
                 self.state_file_path
             ) as memory:
@@ -86,9 +82,11 @@ class LangGraphRuntime(UiPathBaseRuntime):
 
                 graph_config: RunnableConfig = {
                     "configurable": {
-                        "thread_id": self.context.job_id
-                        if self.context.job_id
-                        else "default"
+                        "thread_id": (
+                            self.context.execution_id
+                            or self.context.job_id
+                            or "default"
+                        )
                     },
                     "callbacks": callbacks,
                 }
@@ -101,8 +99,27 @@ class LangGraphRuntime(UiPathBaseRuntime):
                 if max_concurrency is not None:
                     graph_config["max_concurrency"] = int(max_concurrency)
 
+                if self.context.chat_handler:
+                    async for stream_chunk in graph.astream(
+                        processed_input,
+                        graph_config,
+                        stream_mode="messages",
+                        subgraphs=True,
+                    ):
+                        if not isinstance(stream_chunk, tuple) or len(stream_chunk) < 2:
+                            continue
+
+                        _, (message, _) = stream_chunk
+                        event = map_message(
+                            message=message,
+                            conversation_id=self.context.execution_id,
+                            exchange_id=self.context.execution_id,
+                        )
+                        if event:
+                            self.context.chat_handler.on_event(event)
+
                 # Stream the output at debug time
-                if self.is_debug_run():
+                elif self.is_debug_run():
                     # Get final chunk while streaming
                     final_chunk = None
                     async for stream_chunk in graph.astream(

uipath_langchain/_cli/cli_run.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 from os import environ as env
 from typing import Optional
 
@@ -40,7 +41,8 @@ def langgraph_run_middleware(
             context.langgraph_config = config
             context.debug = kwargs.get("debug", False)
             context.logs_min_level = env.get("LOG_LEVEL", "INFO")
-            context.job_id = env.get("UIPATH_JOB_KEY")
+            context.job_id = env.get("UIPATH_JOB_KEY", None)
+            context.execution_id = env.get("UIPATH_JOB_KEY", None)
             context.trace_id = env.get("UIPATH_TRACE_ID")
             context.is_eval_run = kwargs.get("is_eval_run", False)
             context.tracing_enabled = tracing
@@ -64,6 +66,10 @@ def langgraph_run_middleware(
             env["UIPATH_REQUESTING_FEATURE"] = "langgraph-agent"
 
             async with LangGraphRuntime.from_context(context) as runtime:
+                if context.resume is False and context.job_id is None:
+                    # Delete the previous graph state file at debug time
+                    if os.path.exists(runtime.state_file_path):
+                        os.remove(runtime.state_file_path)
                 await runtime.execute()
 
         asyncio.run(execute())

uipath_langchain/_utils/_request_mixin.py

@@ -9,7 +9,7 @@ import httpx
 import openai
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models.chat_models import _cleanup_llm_representation
-from pydantic import BaseModel, Field, SecretStr
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
 from tenacity import (
     AsyncRetrying,
     Retrying,
@@ -37,8 +37,7 @@ def get_from_uipath_url():
 
 
 class UiPathRequestMixin(BaseModel):
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     default_headers: Optional[Mapping[str, str]] = {
         "X-UiPath-Streaming-Enabled": "false",

uipath_langchain/builder/agent_config.py

@@ -0,0 +1,191 @@
+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"
+    )

{uipath_langchain-0.0.124.dist-info → uipath_langchain-0.0.126.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.124
+Version: 0.0.126
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -25,7 +25,7 @@ Requires-Dist: openai>=1.65.5
 Requires-Dist: openinference-instrumentation-langchain>=0.1.50
 Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: uipath<2.2.0,>=2.1.30
+Requires-Dist: uipath<2.2.0,>=2.1.38
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.124.dist-info → uipath_langchain-0.0.126.dist-info}/RECORD

@@ -4,19 +4,21 @@ uipath_langchain/_cli/__init__.py,sha256=juqd9PbXs4yg45zMJ7BHAOPQjb7sgEbWE9InBtG
 uipath_langchain/_cli/cli_dev.py,sha256=VlI8qgCw-63I97tp_9lbXs-CVcNSjpd2sC13YNZAIuU,1401
 uipath_langchain/_cli/cli_init.py,sha256=xhxJ8tuMSrVUNHvltgyPpOrvgMA-wq9shHeYYwvHILs,8199
 uipath_langchain/_cli/cli_new.py,sha256=dL8-Rri6u67ZZdbb4nT38A5xD_Q3fVnG0UK9VSeKaqg,2563
-uipath_langchain/_cli/cli_run.py,sha256=Jr-nxzBaSPQoVrdV1nQBSDVFElFV3N0a0uNDDrdSc8I,3375
+uipath_langchain/_cli/cli_run.py,sha256=R-cUi3lO3Qd4ysTXD7PW4sa1RsB427v_Y6xUQxWijfQ,3725
 uipath_langchain/_cli/_runtime/_context.py,sha256=yyzYJDmk2fkH4T5gm4cLGRyXtjLESrpzHBT9euqluTA,817
+uipath_langchain/_cli/_runtime/_conversation.py,sha256=qobBjb3PEDRQVhrcy8vUXXuzBneELqwphDAU7xEUOqA,9683
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
 uipath_langchain/_cli/_runtime/_input.py,sha256=vZ8vfVxvPSaPWmIPghvNx1VRKzbalHsKUMBPiKDvJWM,5492
 uipath_langchain/_cli/_runtime/_output.py,sha256=yJOZPWv2FRUJWv1NRs9JmpB4QMTDXu8jrxoaKrfJvzw,9078
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=E4aEX4eTjK2XymdKYD1fXNz668S4U2CwEmfL7HSNxjo,14692
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=9X_8YEny238V1sTb4cjkpd6J69DYQWo6eYVH9kA9gEQ,15383
 uipath_langchain/_cli/_templates/langgraph.json.template,sha256=eeh391Gta_hoRgaNaZ58nW1LNvCVXA7hlAH6l7Veous,107
 uipath_langchain/_cli/_templates/main.py.template,sha256=nMJQIYPlRk90iANfNVpkJ2EQX20Dxsyq92-BucEz_UM,1189
 uipath_langchain/_cli/_utils/_graph.py,sha256=JPShHNl0UQvl4AdjLIqLpNt_JAjpWH9WWF22Gs47Xew,7445
 uipath_langchain/_utils/__init__.py,sha256=WoY66enCygRXTh6v5B1UrRcFCnQYuPJ8oqDkwomXzLc,194
-uipath_langchain/_utils/_request_mixin.py,sha256=Tr57358_dwb7SQ1OU75XjdFVWEIr05-QJifeJfHHZgc,19680
+uipath_langchain/_utils/_request_mixin.py,sha256=ddKFs_0mjoFCmvPTiOTPJh1IIqYUo5CUka-B7zAZphE,19695
 uipath_langchain/_utils/_settings.py,sha256=2fExMQJ88YptfldmzMfZIpsx-m1gfMkeYGf5t6KIe0A,3084
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
+uipath_langchain/builder/agent_config.py,sha256=b9WODKPjvufj41Ow_dQn5CnaTAjAZyQoNhuAl8vfiso,5809
 uipath_langchain/chat/__init__.py,sha256=WDcvy91ixvZ3Mq7Ae94g5CjyQwXovDBnEv1NlD5SXBE,116
 uipath_langchain/chat/models.py,sha256=m5PRAFXzUamt6-1K9uSlWUvZg_NfVyYHkgoQDJ-1rGs,10527
 uipath_langchain/embeddings/__init__.py,sha256=QICtYB58ZyqFfDQrEaO8lTEgAU5NuEKlR7iIrS0OBtc,156
@@ -30,8 +32,8 @@ uipath_langchain/tracers/_instrument_traceable.py,sha256=0e841zVzcPWjOGtmBx0GeHb
 uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
 uipath_langchain/vectorstores/__init__.py,sha256=w8qs1P548ud1aIcVA_QhBgf_jZDrRMK5Lono78yA8cs,114
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=TncIXG-YsUlO0R5ZYzWsM-Dj1SVCZbzmo2LraVxXelc,9559
-uipath_langchain-0.0.124.dist-info/METADATA,sha256=zIj8p28Nc1KOTVJ7wjJNCXbsyMAmbx995lA8GdAoeUs,4235
-uipath_langchain-0.0.124.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.124.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.124.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.124.dist-info/RECORD,,
+uipath_langchain-0.0.126.dist-info/METADATA,sha256=rzCwILV0ipPfMnQks58Uh3J2KVNeb9F7FmymzJG0plo,4235
+uipath_langchain-0.0.126.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.126.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.126.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.126.dist-info/RECORD,,