@uipath/skills 1.195.0

package/skills/uipath-admin/references/user-management.md

@@ -0,0 +1,105 @@
+# User Management
+
+Workflows for managing users via `uip admin users`. For full command syntax and flags, see [identity-commands.md](identity-commands.md#users--uip-admin-users).
+
+## Workflow: Onboard a User (canonical flow)
+
+The most common identity flow: invite the user, find them once they accept, and assign them to a group.
+
+### Step 0 — Verify login
+
+```bash
+uip login status --output json
+```
+
+If not logged in: `uip login`. The CLI reads org ID from the active session automatically.
+
+### Step 1 — Invite a user
+
+```bash
+uip admin users invite \
+  --email "<USER_EMAIL>" \
+  --name "<FIRST_NAME>" \
+  --surname "<LAST_NAME>" \
+  --output json
+```
+
+### Step 2 — Find the user once they accept
+
+```bash
+uip admin users list \
+  --search "<USER_EMAIL>" --output json
+```
+
+### Step 3 — Assign to a group
+
+```bash
+uip admin groups list --output json
+uip admin groups members add <GROUP_ID> \
+  --user-ids "<USER_ID>" \
+  --output json
+```
+
+Apply the principal-resolution protocol before the `members add` call — echo `Principal: <displayName> (<userName>) — <id>` from the `users list` result (SKILL.md Rule 5).
+
+## Workflow: Discover Existing Users
+
+```bash
+uip admin users list --output json
+uip admin users list --search "john" --output json
+uip admin users get <USER_ID> --output json
+```
+
+## Workflow: Invite Users by Email (Preferred)
+
+> **`users invite` is the preferred method for adding users.** It sends an invitation email, letting the user set up their own credentials and accept the org invitation. Use `users create` only when direct account provisioning is required (e.g., service accounts, migration scripts). If the user asks to "add" or "create" a user, default to `invite` and confirm before using `create` instead.
+
+```bash
+uip admin users invite \
+  --email "user@example.com" \
+  --name "John" \
+  --surname "Doe" \
+  --output json
+```
+
+- **Always include `--name` and `--surname` when the user's name is known.** Parse first/last name from context (e.g., "Alice Chen" → `--name "Alice" --surname "Chen"`).
+- Invite one user at a time — `--name`/`--surname` apply to the entire request
+- The invited user receives an email and must accept to complete onboarding
+
+## Workflow: Create a User (Direct Provisioning)
+
+> **Ask for confirmation before using this command.** Explain that `users invite` is the standard method for human onboarding and confirm the user specifically wants direct account creation.
+
+Use `create` instead of `invite` when:
+- **Migrations & batch imports** — syncing users from external systems
+
+1. Check for duplicates: `uip admin users list --search "<USERNAME>" --output json`
+2. Create: `uip admin users create "<USERNAME>" --email "<EMAIL>" --name "<FIRST_NAME>" --surname "<LAST_NAME>" --output json`
+3. Verify: `uip admin users list --search "<USERNAME>" --output json`
+
+## Workflow: Update a User
+
+1. Get current details: `uip admin users get <USER_ID> --output json`
+2. Update (at least one field required): `uip admin users update <USER_ID> --email "<NEW_EMAIL>" --output json`
+
+## Workflow: Delete a User
+
+1. Confirm user ID: `uip admin users get <USER_ID> --output json`
+2. Confirm with user before proceeding.
+3. Delete: `uip admin users delete <USER_ID> --output json`
+
+## Pagination and Sorting
+
+```bash
+uip admin users list --limit 20 --offset 0 --output json
+uip admin users list --sort-by "UserName" --sort-order "asc" --output json
+```
+
+## Error Handling
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `already exists` | Username taken | Choose a different username |
+| `No fields to update` | No flags provided to update | Provide `--email`, `--name`, or `--surname` |
+| `user not found` | Invalid user ID | Run `users list` to find the correct ID |
+| `HTTP 403` | Insufficient permissions | User needs admin role in the organization |

package/skills/uipath-agents/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: uipath-agents
+description: "End-to-end work with UiPath Agents of all types: build, integrate with UiPath Products (e.g., Orchestrator, Flow, Maestro), design with UiPath Tools (e.g., Agent Builder/Studio Web), and deploy. Covers Coded Agents (e.g., LangGraph, LlamaIndex, OpenAI Agents) and Low-Code Agents (`agent.json` / Agent Builder). Excludes coded functions / Functions SDK (separate skill)."
+when_to_use: "Must use when user mentions or implies any Agent lifecycle phase - e.g., auth, design, scaffold, Studio Web sync, flow integration, editing, pack/deploy/version bump, eval, tracing, guardrails, memory spaces, bindings, attachments. Example requests: 'create/build a UiPath agent', 'build a low-code / Agent Builder agent', 'add agent memory spaces', 'build a coded / Python agent (LangGraph / LlamaIndex / OpenAI Agents)', 'scaffold an agent project', 'run / evaluate / deploy my agent'."
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion, WebFetch
+user-invocable: true
+---
+
+# UiPath Agents
+
+## Hard Rules
+
+- Treat "build/create/scaffold/implement a UiPath agent" as the full One-Prompt Flow by default. Do not stop after file creation or local run unless the user explicitly says to stop there.
+- A normal completion point is after smoke eval and the mandatory Delivery fork question. A final build summary before that is premature unless run/eval is blocked or the user opted out.
+- **Probe the `solution` verb once per session before the first scaffold or deploy.** Run `uip solution init --help --output json`. Result `Success` → use `solution init` and `solution deploy run --parent-folder-path` / `--parent-folder-key` (post-rename, default). `unknown command` / non-zero exit → CLI predates the rename; substitute `uip solution new <Name>` and `--folder-path` / `--folder-key` (same arguments otherwise) wherever this skill calls those.
+- **Coded agents only — bindings are always derived from UiPath Python SDK calls and must never be hand-authored.** To derive them, always run the sync workflow in [coded/lifecycle/bindings-reference.md](references/coded/lifecycle/bindings-reference.md) — scan code, regenerate `bindings.json`. Without this, resources cannot be overridden per execution environment and will always default to the hardcoded values in the SDK calls. Derive bindings whenever you add, remove, or modify any UiPath SDK resource call — for instance `assets`, `queues`, `processes`, `buckets`, `indexes`, `connections`, `apps`, `MCP servers`, or `InvokeProcess|CreateTask|CreateEscalation(...)`.
+
+## Project Type Detection
+
+Determine the agent mode before proceeding:
+
+1. **Check for existing project files** in the working directory:
+   - `pyproject.toml` with `uipath` dependency + `.py` files → **Coded**
+   - `agent.json` with `"type": "lowCode"` + `project.uiproj`, AND no `pyproject.toml` → **Low-code**
+2. **No existing project found** → ask the user:
+   > Should I build this as a **low-code agent** (no Python — configure through prompts and pre-built UiPath tools) or a **coded agent** (Python — full programmatic control with LangGraph, LlamaIndex, or OpenAI Agents)?
+3. If the user needs help deciding, read [references/coded-vs-lowcode-guide.md](references/coded-vs-lowcode-guide.md) for a capability comparison.
+
+**After detection, read the quickstart for that mode before doing anything else:**
+
+- **Coded** → read [references/coded/quickstart.md](references/coded/quickstart.md). Quickstart's first step detects project state (`greenfield` / `existing-coded` / `local-workspace`) and gates each lifecycle step on it. For Studio Web Local Workspace specifics, see [references/coded/lifecycle/local-workspace.md](references/coded/lifecycle/local-workspace.md).
+- **Low-code** → read [references/lowcode/lowcode.md](references/lowcode/lowcode.md)
+
+## Task Navigation
+
+| I need to... | Mode | Read first | Then |
+|---|---|---|---|
+| Help user choose coded vs low-code | Both | [coded-vs-lowcode-guide.md](references/coded-vs-lowcode-guide.md) | |
+| Authenticate | Both | [authentication.md](references/authentication.md) | |
+| Iterate on a coded agent inside a Studio Web Local Workspace solution | Coded | [coded/quickstart.md](references/coded/quickstart.md) (state detection sets `project_state = local-workspace`) | [coded/lifecycle/local-workspace.md](references/coded/lifecycle/local-workspace.md) for files-owned-by-SW + anti-patterns; `coded/lifecycle/running-agents.md`, `coded/lifecycle/evaluate.md` |
+| Create/build/deploy coded agent | Coded | [coded/quickstart.md](references/coded/quickstart.md) | `coded/lifecycle/*`, `coded/frameworks/*` |
+| Select coded framework | Coded | [coded/quickstart.md](references/coded/quickstart.md) § Framework Selection | |
+| Add coded capabilities (HITL, RAG, tracing) | Coded | [coded/quickstart.md](references/coded/quickstart.md) | `coded/capabilities/*` |
+| Call an Integration Service connector (Slack, Jira, Web Search) from a coded agent | Coded | [coded/capabilities/integration-service.md](references/coded/capabilities/integration-service.md) **+ then immediately read** [`uipath-platform/references/integration-service/agent-workflow.md`](../uipath-platform/references/integration-service/agent-workflow.md) — discovery lives there, not in `uipath-agents` | `coded/capabilities/sdk-services.md` § Connections |
+| Run coded evaluations | Coded | [coded/quickstart.md](references/coded/quickstart.md) § Evaluate | `coded/lifecycle/evaluate.md` |
+| Create or scaffold a new low-code agent project | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Quick Start | `lowcode/project-lifecycle.md`, `lowcode/agent-definition.md` |
+| Edit `agent.json` (prompts, model, schemas, contentTokens, entry-points.json) | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Capability Registry | `lowcode/agent-definition.md` |
+| Add a low-code tool (Orchestrator process — RPA / agent / API / agentic — or Integration Service) | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Capability Registry | `lowcode/capabilities/process/*`, `lowcode/capabilities/integration-service/*` |
+| Accept files as agent input / call the Analyze Files built-in tool | Low-code | [lowcode/capabilities/built-in-tools/built-in-tools.md](references/lowcode/capabilities/built-in-tools/built-in-tools.md) | `lowcode/capabilities/built-in-tools/analyze-attachments.md`, `lowcode/agent-definition.md` § File Attachments |
+| Work with file attachments (input, output, or created mid-run) | Coded | [coded/capabilities/file-attachments.md](references/coded/capabilities/file-attachments.md) | |
+| Build a conversational (chat-style) coded agent | Coded | [coded/capabilities/conversational-agents.md](references/coded/capabilities/conversational-agents.md) | |
+| Add a low-code context (Context Grounding RAG / attachments / DataFabric entity set) | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Capability Registry | `lowcode/capabilities/context/*` |
+| Add a low-code memory space or seed memory items | Low-code | [lowcode/capabilities/memory/memory.md](references/lowcode/capabilities/memory/memory.md) | use `uip agent memory`, then validate/migrate |
+| Add an Action Center escalation (HITL) to a low-code agent | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Capability Registry | `lowcode/capabilities/escalation/escalation.md` |
+| Add guardrails (PII, harmful content, custom rules) to a low-code agent | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Capability Registry | `lowcode/capabilities/guardrails/guardrails.md` |
+| Add guardrails to a coded agent | Coded | [coded/capabilities/guardrails/guardrails.md](references/coded/capabilities/guardrails/guardrails.md) | fetch official docs via WebFetch, ask middleware vs decorator, read agent code, write Python |
+| Add escalation guardrail (escalate action / Action Center app) | Low-code | [lowcode/capabilities/guardrails/guardrails.md](references/lowcode/capabilities/guardrails/guardrails.md) § escalate — Hand Off to Action Center | Run `uip solution resource list --kind App` to confirm app exists |
+| Recommend guardrails for a low-code agent based on its context | Low-code | [lowcode/capabilities/guardrails/guardrails-recommend.md](references/lowcode/capabilities/guardrails/guardrails-recommend.md) | fetch catalog + list, analyze agent context, apply + validate |
+| Recommend guardrails for a specific scope or tool | Low-code | [lowcode/capabilities/guardrails/guardrails-recommend.md](references/lowcode/capabilities/guardrails/guardrails-recommend.md) § Scoped or Tool-Specific Filtering | filter candidates by scope or tool name after catalog analysis |
+| Validate whether existing guardrails are correctly configured | Low-code | [lowcode/capabilities/guardrails/guardrails-recommend.md](references/lowcode/capabilities/guardrails/guardrails-recommend.md) § Validate Mode | check correctness, actionability, and relevance per guardrail |
+| Recommend guardrails for a coded agent based on its context | Coded | [coded/capabilities/guardrails/guardrails-recommend.md](references/coded/capabilities/guardrails/guardrails-recommend.md) | fetch catalog + list + SDK docs, analyze agent code, apply + verify |
+| Recommend guardrails for a specific scope or tool (coded) | Coded | [coded/capabilities/guardrails/guardrails-recommend.md](references/coded/capabilities/guardrails/guardrails-recommend.md) § Scope and Tool Filtering | filter candidates by `@tool` function or scope after catalog analysis |
+| Validate whether existing coded guardrails are correctly configured | Coded | [coded/capabilities/guardrails/guardrails-recommend.md](references/coded/capabilities/guardrails/guardrails-recommend.md) § Validate Mode | check correctness, actionability, and relevance per guardrail |
+| Embed a low-code agent inline in a flow, or wire a multi-agent solution | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) § Capability Registry | `lowcode/capabilities/inline-in-flow/inline-in-flow.md`, `lowcode/capabilities/process/solution-agent.md` |
+| Run low-code evaluations | Low-code | [lowcode/evaluations/evaluate.md](references/lowcode/evaluations/evaluate.md) | `lowcode/evaluations/evaluators.md`, `lowcode/evaluations/evaluation-sets.md`, `lowcode/evaluations/running-evaluations.md` |
+| Run offline evals for a published Orchestrator package | Low-code | [lowcode/evaluations/orchestrator-eval-run.md](references/lowcode/evaluations/orchestrator-eval-run.md) | Use `uip or eval run-offline-evals` (requires package published to Orchestrator) |
+| Validate, pack, publish, upload, or deploy a low-code agent | Low-code | [lowcode/lowcode.md](references/lowcode/lowcode.md) | `lowcode/project-lifecycle.md`, `lowcode/solution-resources.md` |
+| Embed coded agent in a flow (solution-level) | Coded | [coded/embedding-in-flows.md](references/coded/embedding-in-flows.md) | |
+| Use coded agent in a flow | Coded | [coded/flow-integration.md](references/coded/flow-integration.md) | |
+| Use coded agent as tool for another agent in flow | Coded | [coded/flow-integration.md](references/coded/flow-integration.md) § Pattern 3 | |
+| Summarize / research / synthesize over PDF or TXT (DeepRAG, coded) | Coded | [context-grounding-patterns.md](references/context-grounding-patterns.md) | [coded/capabilities/deeprag/planning.md](references/coded/capabilities/deeprag/planning.md) |
+| Summarize / research / synthesize over PDF or TXT (DeepRAG, low-code) | Low-code | [context-grounding-patterns.md](references/context-grounding-patterns.md) | [lowcode/capabilities/built-in-tools/deeprag/planning.md](references/lowcode/capabilities/built-in-tools/deeprag/planning.md) |
+| Process CSV rows with LLM per row (BatchTransform, coded) | Coded | [context-grounding-patterns.md](references/context-grounding-patterns.md) | [coded/capabilities/batch-transform/planning.md](references/coded/capabilities/batch-transform/planning.md) |
+| Process CSV rows with LLM per row (BatchTransform, low-code) | Low-code | [context-grounding-patterns.md](references/context-grounding-patterns.md) | [lowcode/capabilities/built-in-tools/batch-transform/planning.md](references/lowcode/capabilities/built-in-tools/batch-transform/planning.md) |
+
+## Resources
+
+- **UiPath Python SDK**: https://uipath.github.io/uipath-python/
+- **UiPath Evaluations**: https://uipath.github.io/uipath-python/eval/

package/skills/uipath-agents/assets/solutions/metadata.json

@@ -0,0 +1,199 @@
+{
+  "_snapshotDate": "2026-04-24",
+  "_source": "https://<BASE_URL>/<ORG_ID>/studio_/backend/api/resourcebuilder/metadata",
+  "_note": "Trimmed projection: agents only consume {kind, type} for SubType lookup. See bindings-reference.md → SubType Metadata for the refresh recipe.",
+  "entries": [
+    {
+      "kind": "taskCatalog",
+      "type": null
+    },
+    {
+      "kind": "mcpServer",
+      "type": "Coded"
+    },
+    {
+      "kind": "mcpServer",
+      "type": "Command"
+    },
+    {
+      "kind": "mcpServer",
+      "type": "Remote"
+    },
+    {
+      "kind": "mcpServer",
+      "type": "UiPath"
+    },
+    {
+      "kind": "remoteA2aAgent",
+      "type": "RemoteA2aAgent"
+    },
+    {
+      "kind": "app",
+      "type": null
+    },
+    {
+      "kind": "app",
+      "type": "Coded"
+    },
+    {
+      "kind": "app",
+      "type": "CodedAction"
+    },
+    {
+      "kind": "appVersion",
+      "type": null
+    },
+    {
+      "kind": "connection",
+      "type": null
+    },
+    {
+      "kind": "connector",
+      "type": null
+    },
+    {
+      "kind": "choiceSet",
+      "type": null
+    },
+    {
+      "kind": "entity",
+      "type": null
+    },
+    {
+      "kind": "entity",
+      "type": "caseCommentEntity"
+    },
+    {
+      "kind": "entity",
+      "type": "caseDocumentEntity"
+    },
+    {
+      "kind": "entity",
+      "type": "caseMainEntity"
+    },
+    {
+      "kind": "entity",
+      "type": "nativeEntity"
+    },
+    {
+      "kind": "index",
+      "type": null
+    },
+    {
+      "kind": "memorySpace",
+      "type": null
+    },
+    {
+      "kind": "asset",
+      "type": "stringAsset"
+    },
+    {
+      "kind": "asset",
+      "type": "integerAsset"
+    },
+    {
+      "kind": "asset",
+      "type": "booleanAsset"
+    },
+    {
+      "kind": "asset",
+      "type": "credentialAsset"
+    },
+    {
+      "kind": "asset",
+      "type": "secretAsset"
+    },
+    {
+      "kind": "bucket",
+      "type": "orchestratorBucket"
+    },
+    {
+      "kind": "bucket",
+      "type": "amazonBucket"
+    },
+    {
+      "kind": "bucket",
+      "type": "azureBucket"
+    },
+    {
+      "kind": "businessRule",
+      "type": null
+    },
+    {
+      "kind": "calendar",
+      "type": null
+    },
+    {
+      "kind": "credentialStore",
+      "type": null
+    },
+    {
+      "kind": "library",
+      "type": null
+    },
+    {
+      "kind": "package",
+      "type": null
+    },
+    {
+      "kind": "process",
+      "type": null
+    },
+    {
+      "kind": "process",
+      "type": "agent"
+    },
+    {
+      "kind": "process",
+      "type": "api"
+    },
+    {
+      "kind": "process",
+      "type": "caseManagement"
+    },
+    {
+      "kind": "process",
+      "type": "flow"
+    },
+    {
+      "kind": "process",
+      "type": "mcpServer"
+    },
+    {
+      "kind": "process",
+      "type": "process"
+    },
+    {
+      "kind": "process",
+      "type": "processOrchestration"
+    },
+    {
+      "kind": "process",
+      "type": "testAutomationProcess"
+    },
+    {
+      "kind": "process",
+      "type": "webApp"
+    },
+    {
+      "kind": "queue",
+      "type": null
+    },
+    {
+      "kind": "trigger",
+      "type": "connectedEventTrigger"
+    },
+    {
+      "kind": "trigger",
+      "type": "queueTrigger"
+    },
+    {
+      "kind": "trigger",
+      "type": "timeTrigger"
+    },
+    {
+      "kind": "webhook",
+      "type": null
+    }
+  ]
+}

package/skills/uipath-agents/references/authentication.md

@@ -0,0 +1,83 @@
+# UiPath Authentication
+
+Authenticate before running cloud commands. Do not hand-edit auth tokens — use `uip login`. The wrapper resolves the auth env file and injects credentials into forwarded subprocesses, and refreshes the access token automatically when needed; the Python CLI also loads local `.env` on startup. The `uip codedagent` wrapper does not expose an auth subcommand; all auth flows go through `uip login` at the CLI root.
+
+## Command Surface
+
+| Command | Argument style | Purpose |
+|---------|----------------|---------|
+| `uip login` | flags | Establish a session |
+| `uip login status` | none | Report current login state |
+| `uip login tenant list` | none | List tenants for the current session |
+| `uip login tenant set <name>` | positional `<name>` (not `--tenant`) | Switch the active tenant |
+| `uip logout` | none | Clear the session |
+
+## Quick Reference
+
+```bash
+# Status (includes "Expiration Date") — the wrapper auto-refreshes tokens before forwarding cloud commands
+uip login status --output json
+
+# Production cloud (one-shot, non-interactive)
+uip login --organization "<ORG>" --tenant "<TENANT>" --output json
+
+# Staging
+uip login --authority "https://staging.uipath.com/identity_" --organization "<ORG>" --tenant "<TENANT>" --output json
+
+# Alpha
+uip login --authority "https://alpha.uipath.com/identity_" --organization "<ORG>" --tenant "<TENANT>" --output json
+
+# Service principal (unattended)
+uip login --client-id "<ID>" --client-secret "<SECRET>" --base-url "<URL>" --output json
+```
+
+## Critical Rules
+
+- **`uip login status --output json` once per invocation.** Reports `Status`, `Organization`, `Tenant`, `Expiration Date`. When the user has not asked to connect to a specific org/tenant, trust one `Logged in` result — the wrapper auto-refreshes tokens on forwarded cloud calls. No `uip login refresh` subcommand exists. Re-auth only on a real `401`.
+- **If the user supplied environment + organization + tenant, connect with those exact values.** First run/capture `uip login status --output json` if requested or required, then run the matching one-shot command from the Quick Reference (`uip login --organization "<ORG>" --tenant "<TENANT>" --output json`, plus `--authority` for staging/alpha). Do this even if the status check reports an existing `Logged in` session, because the active session may point at a different org/tenant. Do not ask another auth question when all three values are already present.
+- **NEVER run `uip login` without `--tenant`.** The interactive tenant picker cannot be driven from Claude's Bash tool.
+- **When auth is needed and the user did not supply all values, ask one question, then stop.** If the status check shows the user is not logged in and any of environment / organization / tenant is missing, your entire response must be exactly this question — no headers, no bullets, no next-steps:
+
+  > What is your UiPath **environment** (cloud / staging / alpha), **organization name**, and **tenant name**?
+
+  Wait for the reply, then run the matching command from the Quick Reference.
+
+## Environment → Authority Mapping
+
+| User says | Flag to use |
+|-----------|-------------|
+| cloud (default) | no `--authority` flag |
+| staging | `--authority "https://staging.uipath.com/identity_"` |
+| alpha | `--authority "https://alpha.uipath.com/identity_"` |
+
+For on-premise Automation Suite, use `--authority <identity-url>` pointing at your instance.
+
+## Unattended (Service Principal)
+
+```bash
+uip login --client-id "<ID>" --client-secret "<SECRET>" --base-url "<URL>" --output json
+```
+
+Works without a browser. Values for `--client-id` and `--client-secret` can be passed as `env.VAR_NAME` to read from an environment variable.
+
+## If the User Doesn't Know Their Tenant
+
+```bash
+uip login --organization "<ORG>" --output json
+uip login tenant list --output json
+# Present tenants, ask which one:
+uip login tenant set "<SELECTED>" --output json
+```
+
+## Troubleshooting
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `401 Unauthorized` | Session expired | Re-run the appropriate `uip login` command from the Quick Reference |
+| `No tenant selected` | Ran `uip login` without `--tenant` or `--interactive` | Re-run with `--organization <org> --tenant <tenant>` |
+| `Tenant not found` | Tenant name misspelled or user lacks access | Run `uip login tenant list --output json` to see exact names (case-sensitive) |
+| Browser does not open | Running under SSH/container without a default browser | Use service-principal flow (`--client-id`, `--client-secret`) |
+
+## Network Configuration
+
+The CLI honours `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY`, and `REQUESTS_CA_BUNDLE`.

package/skills/uipath-agents/references/coded/capabilities/batch-transform/api-reference.md

@@ -0,0 +1,38 @@
+# BatchTransform — API Reference (Debug Only)
+
+> **Stop.** In a coded agent, use the resume-trigger models (`Create*` / `Wait*` from `uipath.platform.common`) with plain `interrupt()` — see [impl-python.md](impl-python.md). The runtime calls these endpoints for you with the correct headers, body shape, and folder context.
+
+This file lists endpoints for direct invocation from outside an agent (custom tooling, scripts, debugging). Request body shapes evolve with the SDK — **trust the SDK source, not this file**:
+
+- Request specs: `uipath/platform/context_grounding/_context_grounding_service.py` in the installed venv (look for `_*_creation_spec` and `_*_retrieve_spec` methods)
+- Pydantic models (input + response): `uipath/platform/context_grounding/context_grounding.py`
+- Resume-trigger models: `uipath/platform/common/interrupt_models.py`
+- Public docs: <https://uipath.github.io/uipath-python/>
+
+## Verified Endpoint Paths
+
+| Verb | Path | Purpose |
+|---|---|---|
+| POST | `/ecs_/v2/indexes/createephemeral` | Create an ephemeral index over attachments (`usage`: `DeepRAG` or `BatchRAG`) |
+| GET  | `/ecs_/v2/indexes/{id}` | Read index metadata, including `lastIngestionStatus` |
+| POST | `/ecs_/v2/indexes/{index_id}/createDeepRag` | Start a DeepRAG task |
+| POST | `/ecs_/v2/indexes/{index_id}/createBatchRag` | Start a BatchTransform task (the SDK calls it BatchRag internally) |
+| GET  | `/ecs_/v2/deeprag/{id}` | Read DeepRAG task status + content |
+| GET  | `/ecs_/v2/batchRag/{id}` | Read BatchTransform task status + result-file metadata |
+
+All endpoints require either `x-uipath-folderkey` or `x-uipath-folderpath` header.
+
+## Common Errors
+
+| Status | Body fragment | Cause | Fix |
+|---|---|---|---|
+| 400 | `"A folder is required for this action."` | Missing folder header | Set `UIPATH_FOLDER_KEY` env var; in coded agents, pass `index_folder_key` on the resume-trigger model |
+| 400 | `"Summarization requires a successfully completed ingestion process."` | Index not ingested yet | The runtime waits on the index event when you yield `CreateEphemeralIndex`. Hitting this from direct API calls means you skipped the ingestion poll. |
+| 400 | `"The Prompt field is required."` | Empty `prompt` | Pass non-empty prompt |
+| 400 | `outputColumns` validation | Name regex / length | See `BatchTransformOutputColumn` in `context_grounding.py` |
+| 403 | `"User is missing required index permissions."` | Role lacks index permission in folder | Use a folder where the user / agent identity has rights (personal workspace key is the safe default) |
+| 404 | `"Folder does not exist or the user does not have access..."` | Folder name typo or no access | Verify with `sdk.resource_catalog.search_async` |
+
+## Why Not Document Body Shapes Here
+
+Inline JSON shapes drift the moment the SDK changes a field name (e.g., `enableWebSearchGrounding` vs `useWebSearchGrounding`, `globPattern` vs `targetFileGlobPattern`, `Footnote` citation mode that does not exist). Reading the SDK's `_*_creation_spec` methods gives the exact body the platform accepts at the version you are running against. Any inline copy here will be wrong eventually.

package/skills/uipath-agents/references/coded/capabilities/batch-transform/impl-python.md

@@ -0,0 +1,115 @@
+# BatchTransform in a Coded Agent — Implementation
+
+LangGraph + `interrupt()` pattern. **No polling** — runtime suspends on `Create*` resume-trigger models and resumes on the BatchRAG completion event.
+
+
+## Dependencies
+
+```toml
+[project]
+dependencies = ["uipath", "uipath-langchain"]
+```
+
+## Flavour A — Ephemeral index (attachment-backed, one-shot)
+
+### Node: create_index
+
+```python
+from uipath.platform import UiPath
+from uipath.platform.common import UiPathConfig, WaitEphemeralIndex
+from uipath.platform.context_grounding import EphemeralIndexUsage
+from langgraph.types import interrupt
+
+sdk = UiPath()
+if not (folder_key := UiPathConfig.folder_key):
+    folder_key = (await sdk.folders.get_personal_workspace_async()).key
+
+ephemeral_index = await sdk.context_grounding.create_ephemeral_index_async(
+    usage=EphemeralIndexUsage.BATCH_RAG,
+    attachments=[attachment_id],
+    folder_key=folder_key,
+)
+if ephemeral_index.in_progress_ingestion():
+    ephemeral_index = interrupt(WaitEphemeralIndex(index=ephemeral_index))  # → ContextGroundingIndex (ingested)
+```
+
+### Node: run_batch_transform
+
+```python
+from uipath.platform.common import CreateBatchTransform
+from langgraph.types import interrupt
+
+result = interrupt(CreateBatchTransform(
+    name=task_name,
+    index_id=ephemeral_index_id,        # from state, set by create_index node
+    is_ephemeral_index=True,
+    prompt=prompt,
+    output_columns=output_columns,
+    destination_path="results/run-<uuid>.csv",
+    enable_web_search_grounding=False,
+    index_folder_key=index_folder_key,  # from state, set by create_index node
+))
+```
+
+## Flavour B — Existing named index
+
+Skip the `fetch_source`, `upload_attachment`, and `create_index` nodes entirely.
+
+### Node: run_batch_transform
+
+```python
+from uipath.platform.common import CreateBatchTransform
+from langgraph.types import interrupt
+
+result = interrupt(CreateBatchTransform(
+    name=task_name,
+    index_name="<INDEX_NAME>",
+    index_folder_path="<INDEX_FOLDER_PATH>",
+    prompt=prompt,
+    output_columns=output_columns,
+    destination_path="results/run-<uuid>.csv",
+    enable_web_search_grounding=False,
+))
+```
+
+`destination_path` is a LOCAL filesystem path. On resume, the runtime calls `download_batch_transform_result_async(...)` to write the augmented CSV there and returns a confirmation string. Read the CSV from disk if downstream nodes need the rows inline.
+
+## Procedure (Flavour A)
+
+1. **fetch_source** — accept / download the source CSV → local path
+2. **upload_attachment** — `await sdk.attachments.upload_async(name=..., source_path=local, folder_key=folder_key)` → attachment uuid
+3. **create_index** — `create_ephemeral_index_async` → check `in_progress_ingestion()` → conditionally `interrupt(WaitEphemeralIndex(...))` → `ContextGroundingIndex`
+4. **run_batch_transform** — `interrupt(CreateBatchTransform(... is_ephemeral_index=True, index_id=..., output_columns=..., destination_path=<local-path>, index_folder_key=...))` → confirmation string; augmented CSV written to `destination_path`
+5. **finalize** — return the local `destination_path` (or read the CSV from disk for downstream nodes)
+
+Instantiate `UiPath()` inside nodes only — never at module level.
+
+## `BatchTransformOutputColumn` Validation
+
+| Field | Constraint | Notes |
+|---|---|---|
+| `name` | 1–500 chars, regex `^[\w\s\.,!?-]+$` | Friendly column header. No `/`, `:`, `&`, `(`, `)`. |
+| `description` | 1–20000 chars | Per-column LLM instruction. Specify format, enums, "when uncertain" handling. |
+
+## Resume Values
+
+| Yielded model | Resume value | Useful fields |
+|---|---|---|
+| `WaitEphemeralIndex` | `ContextGroundingIndex` | `id`, `folder_key` (ingested) |
+| `CreateBatchTransform` | `str` confirmation message | Format: `"Batch transform completed. Modified file available at <abs_path>"`. Augmented CSV written to the local `destination_path` you supplied — read it from disk if needed. Runtime raises `UiPathFaultedTriggerError` (wrapping `BatchTransformFailedException`) on terminal failure. |
+
+Runtime raises `UiPathFaultedTriggerError` (imported as `from uipath.core.errors import UiPathFaultedTriggerError`) on terminal `Failed`.
+
+## Local-Run Verification
+
+```bash
+uip codedagent run agent '{"instructions":"<PROMPT>","enable_web_search":false}' --output-file out.json
+```
+
+Runtime executes pre-interrupt nodes synchronously, then suspends at `create_index` with the `WaitEphemeralIndex` model captured as the suspend value (Flavour A) or at `run_batch_transform` with `CreateBatchTransform` (Flavour B). That output is correct — not a failure. End-to-end completion happens only on a deployed agent or via `uip codedagent dev`.
+
+## Resources
+
+- UiPath Python SDK: <https://uipath.github.io/uipath-python/>
+- Built-in tool reference (BT/DR/etc.): `uipath_langchain.agent.tools.context_tool` in the installed venv
+- API endpoints (debug): [api-reference.md](api-reference.md)