/uipath-functions

name: uipath-functions
description: "UiPath Coded Functions — deterministic Python or TypeScript/JavaScript units built with the `uip function` CLI (`new -l py|ts|js`, `init`, `serve`, `run`, `pack`, `publish`); the `functions` map in `uipath.json` marks the project. Python: Pydantic Input/Output models, lazy `UiPath()` SDK singleton. JS/TS: `defineFunction` + `defineSchema<T>()` contracts, HTTP endpoints for Coded App backends or run-as-job, `FunctionError`. Rule-based logic, data transforms, ERP/Integration Service calls — invoked as Maestro Service Tasks, from agents, via Orchestrator `POST /Jobs/StartJobs`, or HTTP triggers; no LLM reasoning or agent loop. For LLM/agentic projects (LangGraph, LlamaIndex, OpenAI Agents, `agent.json`)→uipath-agents. For the Coded App frontend itself (React app code, PKCE setup, app deploy)→uipath-coded-apps."
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion

UiPath Coded Functions

Atomic, deterministic units of business logic — no LLM reasoning, no agent loop — written in **Python** or **TypeScript/JavaScript** and shipped as first-class UiPath artifacts. One `uip function` CLI drives both languages. A Coded Function takes typed input, executes deterministic code, and returns typed output; use one when generic activities don't cover the required logic (custom-auth API calls, domain rules, ERP queries via Integration Service, data transforms).

<!--skill-flavor:host-scope:start--> <!--skill-flavor:host-scope:end-->

When to Use This Skill

• Scaffold, author, or modify a coded function in either language (`uip function new <NAME> -l py|ts|js`)
• Declare typed contracts — Pydantic Input/Output (Python) or `defineSchema<T>()` / JSON Schema literals (JS/TS)
• Test locally: `uip function run` (both languages), `uip function serve` + curl (JS/TS HTTP endpoints)
• Error handling: returned error fields (Python), `FunctionError`/status codes and job fault semantics (JS/TS)
• Call UiPath platform APIs from inside a function (Python SDK; `@uipath/uipath-typescript` with `ctx` tokens)
• Wire a Coded App frontend to a JS/TS function backend (tokens, CORS, timeout budget, local dev loop)
• Pack, publish, invoke in production; register in a solution; derive `bindings.json` resource bindings from SDK calls
• Debug deployed failures: cold-start hangs, errorCode 4801/4804/1623, missing tokens, entrypoint errors

Do NOT use this skill for:

• LLM/agentic projects (`agent.json`, LangGraph, LlamaIndex, OpenAI Agents, agent loop) → `uipath-agents`
• The Coded App frontend itself (React/Vite app code, PKCE setup, app deploy) → `uipath-coded-apps`

Language Split

Detect an existing project by its signals before doing anything; for a new project the language follows the caller's stack.

| | Python | JS/TS | |---|---|---| | Scaffold | `uip function new <NAME> -l py` (`-l py` required) | `uip function new <NAME> -l ts` / `-l js` (ts is the CLI default) | | Project signals | `pyproject.toml` + `uipath.json` functions map | `package.json` + `uipath.json` functions map | | Contracts | Pydantic `BaseModel` / `@dataclass` Input/Output | `defineSchema<T>()` (TS) / JSON Schema literal (JS) | | Entrypoints | `"main": "main.py:<fn>"`, generated by `uip function init` | `functions/<FILE>.ts:default`, auto-synced; no `init` | | Calling mode | run-as-job (Maestro, agents, Orchestrator API) | one declared mode: HTTP endpoint or run-as-job — never both | | Local dev | `uip function run` | `uip function serve` (HTTP on :7070) / `uip function run` (one-shot job) | | References | [references/python/](references/python/workflow-guide.md) | [references/js/](references/js/authoring-guide.md) |

Job-startable functions are invoked from Maestro BPMN/Flow (Service Task), coded agents (as a tool or step), other functions, the Orchestrator API (`POST /Jobs/StartJobs`), or schedules/triggers. A JS/TS **HTTP-mode** function is instead called synchronously through its Orchestrator HTTP trigger ([references/js/http-semantics-guide.md](references/js/http-semantics-guide.md)).

Critical Rules

Both languages

1. **No LLM calls inside a Coded Function.** LLM reasoning breaks the deterministic contract — that project is an agent → `uipath-agents`. 2. **The `functions` map in `uipath.json` identifies the project as a Coded Function** — it is the marker every tool reads. 3. **Cloud-backed work needs auth**: `uip login --organization "<ORG>" --tenant "<TENANT>" --output json`.

Python

1. **`UiPath()` must never be instantiated at module level** — lazy singleton inside a getter. 2. **Errors are returned, not raised**: populate `error_type`/`error_message` output fields; never let exceptions bubble out of the entrypoint. 3. **`uip function init` must run before `pack` or `push`** — it generates `entry-points.json` and `project.uiproj` and creates `bindings.json` as an empty skeleton when the file is absent; re-run after any schema or entrypoint change. It never derives bindings from code (Rule 7). 4. **Typed I/O is mandatory** — Pydantic `BaseModel`, `pydantic.dataclasses.dataclass`, stdlib `@dataclass`, or a thin typed class; apply `@traced(name=..., run_type="uipath")` to the entrypoint for LLM Ops Traces. 5. **`pyproject.toml` needs `authors`** (else `pack` rejects: `Project authors cannot be empty`) and no `[build-system]` section. 6. **`uip function new -l py` produces a function scaffold** — `uipath.json` with a `functions` map, no `langgraph.json` — regardless of any agent framework package (`uipath-langchain`, `uipath-llamaindex`, `uipath-openai-agents`) installed in the venv. 7. **Bindings are derived from `uipath` SDK calls — never left empty, never guessed.** `init` leaves `"resources": []`. Every `sdk().assets` / `queues` / `processes` / `buckets` / `context_grounding` / `connections` / `mcp` / `tasks` call needs a matching `bindings.json` entry, produced by the sync workflow in [references/python/bindings-reference.md](references/python/bindings-reference.m