Merge branch 'main' of https://github.com/UiPath/uipath-langchain-python into feat-df-agent-integrations-fixes

Author: milind-jain-uipath

.github/workflows/commitlint.yml

@@ -16,32 +16,5 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: Setup Node
-        uses: actions/setup-node@v3
-        with:
-          node-version: 22
-
-      - name: Install Git
-        run: |
-          if ! command -v git &> /dev/null; then
-              echo "Git is not installed. Installing..."
-              sudo apt-get update
-              sudo apt-get install -y git
-          else
-              echo "Git is already installed."
-          fi
-
-      - name: Install commitlint
-        run: |
-          npm install conventional-changelog-conventionalcommits
-          npm install commitlint@latest
-          npm install @commitlint/config-conventional
-
-      - name: Configure
-        run: |
-          echo "export default { extends: ['@commitlint/config-conventional'] };" > commitlint.config.js
-
       - name: Validate PR commits with commitlint
-        run: |
-          git fetch origin pull/${{ github.event.pull_request.number }}/head:pr_branch
-          npx commitlint --from ${{ github.event.pull_request.base.sha }} --to pr_branch --verbose
+        uses: wagoid/commitlint-github-action@b948419dd99f3fd78a6548d48f94e3df7f6bf3ed # v6

CLAUDE.md

@@ -0,0 +1,82 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`uipath-langchain` is a Python SDK that extends UiPath's Python SDK with LangChain/LangGraph integration. It implements the UiPath Runtime Protocol to deploy LangGraph agents to UiPath Cloud Platform. Requires Python 3.11+.
+
+## Common Commands
+
+```bash
+# Install dependencies (uses uv)
+uv sync --all-extras
+
+# Run all tests
+uv run pytest
+
+# Run a single test file
+uv run pytest tests/path/to/test_file.py
+
+# Run a single test
+uv run pytest tests/path/to/test_file.py::test_name
+
+# Lint
+just lint              # ruff check + httpx client lint
+just format            # ruff format check + fix
+
+# Build
+uv build
+```
+
+## Architecture
+
+### Package: `src/uipath_langchain/`
+
+- **`runtime/`** — `UiPathLangGraphRuntime` executes LangGraph graphs within the UiPath framework. Async execution with streaming, breakpoints, and message mapping. Registered as an entry point via `uipath_langchain.runtime:register_runtime_factory`.
+
+- **`agent/`** — Agent implementation with sub-packages:
+  - `react/` — ReAct agent pattern (agent, LLM node, router, tool node, guardrails)
+  - `tools/` — Structured tools: context, escalation, extraction, integration, process, MCP adapters, durable interrupts. All inherit from `BaseUiPathStructuredTool`.
+  - `guardrails/` — Input/output validation within agent execution
+  - `multimodal/` — Multimodal invoke support
+  - `exceptions/` — Structured error types (`AgentRuntimeError`, `AgentStartupError`) and helpers for agent error handling
+  - `wrappers/` — Agent decorators and wrappers
+
+- **`chat/`** — LLM provider interfaces for OpenAI, Azure OpenAI, AWS Bedrock, Google Vertex AI. Uses **lazy imports** via `__getattr__` in `__init__.py` to keep CLI startup fast. Includes `hitl.py` with the `requires_approval` decorator for human-in-the-loop workflows. Factory pattern via `chat_model_factory.py`.
+
+- **`retrievers/`** and **`vectorstores/`** — Context grounding retrieval and vector storage.
+
+- **`guardrails/`** — Top-level guardrails with actions, enums, models, and middleware.
+
+- **`_cli/`** — CLI commands (`uipath init`, `uipath new`) with project templates.
+
+- **`_tracing/`** — OpenTelemetry instrumentation.
+
+- **`_utils/`** — Shared utilities: HTTP request mixin, settings, sleep policy, environment helpers.
+
+- **`middlewares.py`** — Entry point registered as `uipath_langchain.middlewares:register_middleware`.
+
+### Entry Points (pyproject.toml)
+
+The package registers two entry points consumed by the `uipath` CLI:
+- `uipath.middleware` → `uipath_langchain.middlewares:register_middleware`
+- `uipath.runtime_factory` → `uipath_langchain.runtime:register_runtime_factory`
+
+## Key Conventions
+
+- **httpx clients**: Always use `**get_httpx_client_kwargs()` when constructing `httpx.Client()` or `httpx.AsyncClient()`. A custom AST linter (`scripts/lint_httpx_client.py`) enforces this — it runs as part of `just lint`.
+
+- **Lazy imports**: The `chat/` module defers heavy imports (langchain_openai, openai SDK) to optimize CLI startup. Use `__getattr__` pattern in `__init__.py` when adding new chat model providers.
+
+- **Naming conventions for SDK methods**: `retrieve` (single by key), `retrieve_by_[field]` (single by other field), `list` (multiple resources).
+
+- **Testing**: pytest only (no unittest). Tests in `./tests/` mirror source structure. Use pytest-asyncio for async tests (mode: auto). A circular import test (`test_no_circular_imports.py`) auto-discovers and validates all modules.
+
+- **Type annotations**: All functions and classes require type annotations. Public APIs require Google-style docstrings.
+
+- **Linting**: Ruff with rules E, F, B, I. Line length 88. mypy with pydantic plugin for type checking.
+
+- **Bedrock/Vertex imports**: `bedrock.py` and `vertex.py` have per-file E402 ignores for conditional imports.
+
+- **Exception handling in `agent/`**: Use the error types and helpers from `agent/exceptions/`. Do not raise raw exceptions or invent new error types. New error codes may be defined.

docs/sample_images/ticket-classification/app-binding-package-requirements.png

@@ -1,13 +1,13 @@
 [project]
 name = "uipath-langchain"
-version = "0.8.14"
+version = "0.9.2"
 description = "Python SDK that enables developers to build and deploy LangGraph agents to the UiPath Cloud Platform"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 dependencies = [
-    "uipath>=2.10.0, <2.11.0",
+    "uipath>=2.10.22, <2.11.0",
     "uipath-core>=0.5.2, <0.6.0",
-    "uipath-platform>=0.0.18, <0.1.0",
+    "uipath-platform>=0.1.5, <0.2.0",
     "uipath-runtime>=0.9.1, <0.10.0",
     "langgraph>=1.0.0, <2.0.0",
     "langchain-core>=1.2.11, <2.0.0",

pyproject.toml

@@ -94,6 +94,26 @@ cd uipath-langchain-python/samples/ticket-classification
 
 The Ticket Classification Agent utilizes HITL (Human In The Loop) technology, allowing the system to incorporate feedback directly from supervisory personnel. We'll leverage UiPath [Action Center](https://docs.uipath.com/action-center/automation-suite/2023.4/user-guide/introduction) for this functionality.
 
+There are two ways to configure the escalation app:
+
+#### Option A: Use App Bindings (recommended — no code changes required)
+
+After publishing the agent package, you can override the escalation app directly from the **Package Requirements** tab in UiPath, without modifying any code. This is made possible by the `bindings.json` file included in this sample.
+
+![app-binding-package-requirements](../../docs/sample_images/ticket-classification/app-binding-package-requirements.png)
+
+In the **Package Requirements** tab, select the app you want to use as the escalation app. The app you bind **must respect the following contract** expected by the agent code:
+
+- **Inputs:**
+  - `AgentOutput` (string) — the classification summary sent to the reviewer
+  - `AgentName` (string) — the name of the agent creating the task
+- **Output:**
+  - `Answer` (boolean) — `true` to approve, `false` to reject
+
+> This approach allows you to use any compatible UiPath App as the escalation interface, swapping it out without redeploying or editing code.
+
+#### Option B: Deploy the pre-built solution app
+
 Follow these steps to deploy the pre-built application using [UiPath Solutions Management](https://docs.uipath.com/solutions-management/automation-cloud/latest/user-guide/solutions-management-overview):
 
 1. **Upload Solution Package**

samples/ticket-classification/README.md

@@ -0,0 +1,26 @@
+{
+    "version": "2.0",
+    "resources": [
+          {
+      "resource": "app",
+      "key": "escalation_agent_app.app_folder_path",
+      "value": {
+        "name": {
+          "defaultValue": "escalation_agent_app",
+          "isExpression": false,
+          "displayName": "App Name"
+        },
+        "folderPath": {
+          "defaultValue": "app_folder_path",
+          "isExpression": false,
+          "displayName": "App Folder Path"
+        }
+      },
+      "metadata": {
+        "ActivityName": "create_async",
+        "BindingsVersion": "2.2",
+        "DisplayLabel": "app_name"
+      }
+    }
+    ]
+}

samples/ticket-classification/bindings.json

@@ -125,7 +125,7 @@ async def wait_for_human(state: GraphState) -> Command:
                                              "AgentName": "ticket-classification "},
                                          app_version=1,
                                          assignee=state.get("assignee", None),
-                                         app_folder_path="FOLDER_PATH_PLACEHOLDER",
+                                         app_folder_path="app_folder_path",
                                          ))
 
     return Command(

samples/ticket-classification/main.py

@@ -31,7 +31,7 @@ def generate_pyproject(target_directory, project_name):
 description = "{project_name}"
 authors = [{{ name = "John Doe", email = "john.doe@myemail.com" }}]
 dependencies = [
-    "uipath-langchain>=0.2.0",
+    "uipath-langchain>=0.8.0, <0.9.0",
 ]
 requires-python = ">=3.11"
 """

src/uipath_langchain/_cli/cli_new.py

@@ -1,6 +1,9 @@
 """Durable interrupt package for side-effect-safe interrupt/resume in LangGraph."""
 
-from .decorator import _durable_state, durable_interrupt
+from .decorator import (
+    _durable_state,
+    durable_interrupt,
+)
 from .skip_interrupt import SkipInterruptValue
 
 __all__ = [