feat(functions): add Functions service for invoking coded functions [PLT-106037]

[amrit-agarwal-1]

Method Added

Layer	Method	Signature
Service	functions.getAll()	getAll<T extends FunctionGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<FunctionGetResponse> : NonPaginatedResponse<FunctionGetResponse>>
Service	functions.invoke()	invoke<TInput extends object, TOutput>(name: string, input?: TInput, options?: FunctionInvokeOptions): Promise<TOutput>
Bound	fn.invoke()	invoke<TInput extends object, TOutput>(input?: TInput): Promise<TOutput>

Endpoint Called

Method	HTTP	Endpoint	OAuth Scope
getAll()	GET	orchestrator_/odata/HttpTriggers	OR.Default
invoke()	GET	orchestrator_/odata/HttpTriggers (name lookup)	OR.Default
invoke()	GET	orchestrator_/odata/Folders({id}) (folder key resolution)	OR.Folders or OR.Folders.Read
invoke()	POST/GET	orchestrator_/t/{folderKey}/{processSlug}/{slug} (HTTP trigger)	OR.Default

• New modular service @uipath/uipath-typescript/functions. Internal class FunctionService, public alias Functions. Extends FolderScopedService.
• A coded function is packaged as a process and exposed through an HTTP (API) trigger; this service masks that so pro devs work with functions directly rather than composing Processes + Triggers.
• Folder context is accepted as folderId, folderKey, or folderPath (or resolved from the SDK's init-time folder context), via the shared resolveFolderHeaders utility.
• getAll() supports OData pagination ($top, $skip, $count) and filtering; a function maps 1:1 to an HTTP trigger, so listing is done at the trigger level.
• invoke() is composite (see flow below). It calls the HTTP trigger directly — not Processes.start() — so HTTP-mode function context is preserved. Invocation is synchronous (the platform long-polls the job and returns the output as the HTTP response body). Functions declared with Get receive input as query parameters; all other verbs receive it as the JSON body.

Example Usage

import { UiPath } from '@uipath/uipath-typescript/core';
import { Functions } from '@uipath/uipath-typescript/functions';

const sdk = new UiPath(config);
await sdk.initialize();
const functions = new Functions(sdk);

// Discover functions in a folder
const all = await functions.getAll({ folderId: <folderId> });

// Invoke by name
const result = await functions.invoke('hello', { name: 'Alice' }, { folderId: <folderId> });

// Typed input/output, folder by path
interface HelloInput { name: string }
interface HelloOutput { message: string }
const typed = await functions.invoke<HelloInput, HelloOutput>(
  'hello',
  { name: 'Alice' },
  { folderPath: 'Shared/Finance' }
);
console.log(typed.message);

// Bound invoke on a discovered function
const hello = all.items.find(f => f.name === 'hello');
if (hello) {
  const out = await hello.invoke({ name: 'Alice' });
}

API Response vs SDK Response

getAll — Transform pipeline

pascalToCamelCaseKeys(row) → manual reshape to RawFunctionGetResponse (flattens nested release) → createFunctionWithMethods() (attaches bound invoke)

Field mapping (getAll, raw HttpTriggers row → SDK)

API Response (PascalCase)	SDK Response (camelCase)	Change	Reason
OrganizationUnitId	folderId	Case + Rename	Standard folder rename
OrganizationUnitFullyQualifiedName	folderName	Case + Rename	Standard folder rename
ReleaseKey	processKey	Case + Rename	Release = process in SDK terms
Release.Name	processName	Reshape	Flatten nested release
Release.Slug	processSlug	Reshape	Flatten nested release
Id, Name, Slug, Method, Description, Enabled, InputArguments, EntryPointPath	id, name, slug, method, description, enabled, inputArguments, entryPointPath	Case	camelCase conversion
JobPriority, RunAsCaller, CallingMode, MachineRobots, … (~25 job-runner fields)	—	Dropped	Platform plumbing, not function DX

invoke — Composition flow

invoke(name, input?, {folderId|folderKey|folderPath}?)
  1. GET  /odata/HttpTriggers  ($filter=Name eq '<name>', folder-scoped)  -> slug, method, processSlug
  2. resolve folder key:
       options.folderKey  ->  use it
       else SDK-init folder context (no explicit folder)  ->  use it
       else GET /odata/Folders({folderId})  ->  Key   (cached)
  3. POST /t/{folderKey}/{processSlug}/{slug}   (body = input ?? {})
       (Get-method functions -> GET with input as query params)
     -> HTTP response body = function output (typed as TOutput)

Internal types (not exported)

Type	Purpose
RawFunctionTrigger	Raw /odata/HttpTriggers row (camelCased) before reshape
RawFolderResponse	Minimal /odata/Folders({id}) shape — folder Key only

Sample SDK Response

getAll()

{
  "items": [
    {
      "id": "e758581f-2f78-4d86-a8e9-f4bc3aad52ec",
      "name": "hello",
      "slug": "hello",
      "method": "Post",
      "description": "Returns a greeting message.",
      "enabled": true,
      "inputArguments": "{\"name\":\"World\"}",
      "entryPointPath": "content/functions/hello.ts",
      "processKey": "d1519612-2961-488e-af7a-7379cc1c3544",
      "processName": "my-functions",
      "processSlug": "my-functions",
      "folderId": 2843389,
      "folderName": "Shared/Solution 121 new"
    }
  ],
  "totalCount": 1
}

invoke('hello', { name: 'Alice' }, { folderId })

{ "message": "Hello, Alice!" }

🤖 Auto-generated using onboarding skills

[github-actions]

PR Preview Action v1.8.1
🚀 View preview at https://UiPath.github.io/uipath-typescript/pr-preview/pr-614/
Built to branch gh-pages at 2026-07-28 21:18 UTC. Preview will be ready when the GitHub Pages deployment is complete.

[claude]

Orphaned {@link} tag — this line renders as stray text (or a dangling link) in TypeDoc output. It appears to be a copy-paste artifact; the @returns description on the line above already includes the two relevant links. Remove this line.

Suggested change

* @returns Promise resolving to either an array of functions {@link NonPaginatedResponse}<{@link FunctionGetResponse}> or a {@link PaginatedResponse}<{@link FunctionGetResponse}> when pagination options are used.

[claude]

Convention requires afterEach(() => { vi.clearAllMocks(); }) even when mocks are recreated in beforeEach. The service test file includes this; the model test should too for consistency.

Suggested change

	});
	});
	afterEach(() => {
	vi.clearAllMocks();
	});

[claude]

Review findings

Three minor convention violations flagged:

tests/utils/mocks/functions.ts line 10 — createMockRawFunctionTrigger uses Partial<any> / : any. Use Partial<Record<string, unknown>> / Record<string, unknown> instead (no-any rule).

tests/unit/models/orchestrator/functions.test.ts line 17 — Model test is missing afterEach(() => { vi.clearAllMocks(); }). The companion service test has it; convention requires it here too.

src/models/orchestrator/functions.constants.ts line 2 — JSDoc says "Field mapping for Function responses" but FunctionMap is never passed to transformData() — toFunctionResponse does the reshape manually. The map is only consumed by transformOptions for OData filter/orderby rewriting. Updated comment proposed to prevent future confusion.

Everything else looks correct: @track decorators present on both public methods, JSDoc only on FunctionServiceModel (not duplicated on the class), barrel exports use export * from (not export type *), folder options destructured before PaginationHelpers.getAll, transform pipeline validated in both unit and integration tests, docs/oauth-scopes.md and docs/pagination.md updated, subpath export wired in package.json and rollup.config.js.

[claude]

✅ No issues found. Checked for bugs and CLAUDE.md compliance.