@uipath/skills 1.200.0 → 1.201.0-preview.433

package/skills/uipath-coded-apps/references/widgets/external-auth.md

@@ -0,0 +1,97 @@
+# External Auth Widget
+
+Provider-agnostic React **sign-in screen**: renders one "Continue with {Provider}" button per configured authentication provider and starts the login **directly at that provider's IdP**. Ships a built-in OIDC authorization-code redirect (CSRF `state` + PKCE) enabled per provider via an `oauth` config; a per-provider `onSignIn` handler always wins over it.
+
+Package: [`@uipath/ui-widgets-external-auth`](https://www.npmjs.com/package/@uipath/ui-widgets-external-auth). Full prop/API surface lives in the package README — this file covers only the integration steps that are easy to get wrong inside a Coded App.
+
+> **Publish status:** this package is newer than the other widgets. Before recommending it, verify it resolves: `npm view @uipath/ui-widgets-external-auth version`. On a 404 the package is not yet on the public registry — tell the user instead of inventing an install path.
+
+## When to Use
+
+- The coded app is a **user-facing portal whose end users sign in with external identity providers** (Google, UAE PASS, a corporate SAML IdP) — the widget is the front-door sign-in screen.
+- **NOT for signing in to UiPath.** Coded web apps authenticate to UiPath Cloud via the built-in OAuth-PKCE flow (`useAuth()` / `sdk.initialize()` — see [../create-web-app.md](../create-web-app.md)); action apps use the host-injected session. Never replace those with this widget.
+
+## Critical Rules
+
+1. **This widget only STARTS the login.** Everything after the browser leaves the page — the callback route, `state`/PKCE verification, code→token exchange, session creation — is the app's (or its backend's) responsibility. Rendering the widget without building the callback side yields a sign-in that goes nowhere.
+2. **Each provider needs `onSignIn` or `oauth`** (`onSignIn` wins when both are set). With neither, the button click logs a console warning and does nothing.
+3. **The built-in default covers OIDC-style providers only.** It builds an authorization-code redirect with CSRF `state` and PKCE, then navigates to the provider. **SAML cannot be started from the browser** — SAML providers must use `onSignIn` pointing at a backend Service Provider route (e.g. `window.location.assign('/auth/saml/login?connection=' + clientId)`).
+4. **The callback route must read the persisted `state`/`codeVerifier`.** The built-in redirect stores them in `sessionStorage` under `uipath-external-auth:oauth:<clientId>` — verify `state` matches and send `codeVerifier` in the token exchange.
+5. **Never put a provider client secret in the app.** The flow is a public-client authorization-code + PKCE redirect; secret-bearing exchanges belong on a backend.
+6. **No UiPath scopes needed.** The widget makes no UiPath API calls, so it adds nothing to the `scope` field in `uipath.json`. (It still peer-depends on `@uipath/uipath-typescript` for telemetry.)
+7. **Import the stylesheet once**: `import '@uipath/ui-widgets-external-auth/ExternalAuth.css'`. Body needs `light` or `dark` class. Peers: `react >= 19.2.0`, `react-dom >= 19.2.0`, `@uipath/uipath-typescript >= 1.4.1`.
+8. **Redirect URIs must be registered at the provider.** The `oauth.redirectUri` you pass must exactly match a redirect URI configured in the provider's console (per environment — local dev vs deployed app URL).
+
+## Install
+
+From inside the scaffolded app directory (after the publish check above):
+
+```bash
+npm install @uipath/ui-widgets-external-auth --@uipath:registry=https://registry.npmjs.org
+```
+
+Registry flag forces the public npm registry (skill default — users may have `@uipath` scoped to GitHub Packages).
+
+## Key Props
+
+| Prop | Required | Notes |
+|------|----------|-------|
+| `authProviders` | Yes | `AuthProvider[]` — one button per entry, rendered in order. |
+| `title` | No | Heading (default "Sign in to your account"). |
+
+`AuthProvider`:
+
+| Field | Required | Notes |
+|-------|----------|-------|
+| `displayName` | Yes | Button label — `"Google"` renders "Continue with Google". |
+| `clientId` | Yes | Opaque to the widget; passed back to `onSignIn` and used by the `oauth` default. |
+| `displayIcon` | No | String → `<img src>`; anything else (inline SVG element) renders as-is. |
+| `onSignIn` | No* | `(clientId) => void \| Promise<void>` — always wins; required for non-OIDC (SAML). |
+| `oauth` | No* | `OAuthRedirectConfig` — enables the built-in OIDC redirect when `onSignIn` is omitted. |
+
+`OAuthRedirectConfig`: `authorizeUrl` + `redirectUri` + `scopes` (required); `responseType` (default `code`), `usePkce` (default `true`), `extraParams` (e.g. `{ acr_values: '...' }` for UAE PASS).
+
+Also exported: `buildOAuthAuthorizeUrl(clientId, config)` and `createDefaultSignIn(config)` for composing custom handlers.
+
+## Integration
+
+```typescript
+import { ExternalAuth } from '@uipath/ui-widgets-external-auth';
+import '@uipath/ui-widgets-external-auth/ExternalAuth.css';
+
+function SignInPage() {
+  return (
+    <ExternalAuth
+      authProviders={[
+        {
+          displayName: 'Google',
+          clientId: '<GOOGLE_CLIENT_ID>',
+          oauth: {
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            redirectUri: `${window.location.origin}/auth/google/callback`,
+            scopes: 'openid email profile',
+          },
+        },
+        {
+          displayName: 'Corporate SSO',
+          clientId: '<SAML_CONNECTION_ID>',
+          onSignIn: (clientId) =>
+            window.location.assign(`/auth/saml/login?connection=${clientId}`),
+        },
+      ]}
+    />
+  );
+}
+```
+
+Callback route sketch (the part the widget does NOT do): parse `code` + `state` from the query string → load `sessionStorage['uipath-external-auth:oauth:<clientId>']` → verify `state` → POST the token exchange (with `codeVerifier`) from your backend → create the app session → clean up the storage entry.
+
+> Deployed coded apps mount at a non-root prefix — build `redirectUri` and the callback route path with `getAppBase()` from `@uipath/uipath-typescript` (skill Critical Rule 10), and register the resulting absolute URL at the provider.
+
+## Anti-patterns
+
+- **Do not use this widget to sign in to UiPath Cloud** — that is the scaffold's built-in PKCE flow (`useAuth()`), not an external provider button.
+- **Do not expect the widget to complete the login** — it only starts the redirect; without your callback route, nothing signs in.
+- **Do not start SAML from the browser via `oauth`** — SAML requires a backend-initiated flow through `onSignIn`.
+- **Do not embed provider client secrets** in app code or `oauth` config — public client + PKCE only; exchanges needing a secret run on a backend.
+- **Do not configure a provider with neither `onSignIn` nor `oauth`** — the button becomes a silent no-op.

package/skills/uipath-coded-apps/references/widgets/multi-file-upload.md

@@ -0,0 +1,98 @@
+# Multi-File Upload Widget
+
+React widget that uploads multiple files concurrently to an **Orchestrator Storage Bucket** — drag-and-drop, file-type/size validation, per-file error tracking, partial-success handling.
+
+Package: [`@uipath/ui-widgets-multi-file-upload`](https://www.npmjs.com/package/@uipath/ui-widgets-multi-file-upload). Full prop/API surface lives in the package README — this file covers only the integration steps that are easy to get wrong inside a Coded App.
+
+> **Publish status — check the peer range first:** `npm view @uipath/ui-widgets-multi-file-upload version peerDependencies`. The published **1.0.0** pins `@uipath/uipath-typescript@1.1.1` **exactly** and is runtime-broken on SDK >= 1.5: `npm install` fails with ERESOLVE, and forcing it in fails at upload time with `telemetryClient.track is not a function` (the widget calls a telemetry API removed from newer SDKs). It also cannot coexist with the chat widget (peer `^1.5.5`) in one app. Until a version with peer `^1.4.1` ships, install a tarball built from the `uipath-ui-widgets` repo, or hand-roll the upload via `Buckets.uploadFile()` and say why.
+
+## When to Use
+
+- User asks to **upload files/documents** from the app into a storage bucket (e.g., feeding a DU or RPA pipeline's input folder).
+- Replaces a hand-rolled `<input type="file">` + `Buckets.uploadFile()` loop — the widget already handles concurrency, validation, retry-of-failed, and error display.
+- To *display* an uploaded PDF afterwards, pair with the PDF Viewer widget ([pdf-viewer.md](pdf-viewer.md)).
+
+## Critical Rules
+
+1. **Peer versions are hard requirements.** `react >= 19.2.0`, `react-dom >= 19.2.0`, `@uipath/uipath-typescript >= 1.4.1` — the SDK floor applies to widget versions **newer than 1.0.0**; see the publish-status warning above.
+2. **Import the stylesheet once**: `import '@uipath/ui-widgets-multi-file-upload/MultiFileUpload.css'`. Body needs `light` or `dark` class.
+3. **Required scope: `OR.Buckets`** — upload is a write; read-only `OR.Buckets.Read` is insufficient. Add to the `scope` field in `uipath.json` before first run; mismatch fails with 401/403. See [../oauth-scopes.md](../oauth-scopes.md).
+4. **`bucketId` and `folderId` are numbers.** `folderId` is the Orchestrator folder containing the bucket — a numeric id, **not** the folder GUID (`folderKey`). At runtime resolve via `new Buckets(sdk).getAll({ folderId })`; never `parseInt(folderKey)` (bridge via [Bridging folderKey ↔ folderId](../sdk/orchestrator.md#bridging-folderkey--folderid)). CLI lookup: bucket ids via `uip or buckets list --all-folders --output json` (`Id` field); the numeric folder id via `uip or folders get <FOLDER_KEY_OR_PATH> --output json` → `Data.Id` — `folders list` returns only GUID `Key`s, and `folders get` 404s for personal workspaces (resolve those at runtime instead).
+5. **Handle BOTH callbacks — partial success is a first-class outcome.** `onUploadSuccess(files)` receives **only the files that uploaded**; failed files stay in the list (with per-file errors) for the user to retry. `onUploadError` fires when the whole batch fails. Wiring only `onUploadSuccess` hides partial failures from your app logic.
+6. **Reuse the app's initialized `UiPath` instance** (`useAuth()` in web apps); do not construct a second SDK.
+7. **No special `vite.config.ts` setup** — no asset plugins or `optimizeDeps` changes needed.
+
+## Install
+
+From inside the scaffolded app directory:
+
+```bash
+npm install @uipath/ui-widgets-multi-file-upload --@uipath:registry=https://registry.npmjs.org
+```
+
+Registry flag forces the public npm registry (skill default — users may have `@uipath` scoped to GitHub Packages).
+
+## Key Props
+
+| Prop | Required | Notes |
+|------|----------|-------|
+| `sdk` | Yes | Initialized `UiPath` instance from `useAuth()`. |
+| `bucketId` | Yes | Numeric storage bucket id. |
+| `folderId` | Yes | Numeric id of the folder containing the bucket. |
+| `path` | No | Key prefix for uploads (e.g. `"uploads/"` — trailing slash added if missing). |
+| `accept` | No | Comma-separated extensions/MIME types (standard HTML `accept` semantics). |
+| `maxFileSizeInMb` | No | Per-file size cap; oversize files are rejected client-side. |
+| `onUploadSuccess` | No | `(uploadedFiles: File[]) => void` — successful files only (may be a subset). |
+| `onUploadError` | No | `(error: Error) => void` — whole-batch failure. |
+
+## Integration: Web App
+
+Upload into a bucket and refresh a listing on success:
+
+```typescript
+import { MultiFileUpload } from '@uipath/ui-widgets-multi-file-upload';
+import '@uipath/ui-widgets-multi-file-upload/MultiFileUpload.css';
+import { Buckets } from '@uipath/uipath-typescript/buckets';
+import { useCallback, useMemo } from 'react';
+import { useAuth } from '../hooks/useAuth';
+
+function UploadPage({ bucketId, folderId }: { bucketId: number; folderId: number }) {
+  const { sdk } = useAuth();
+  const buckets = useMemo(() => new Buckets(sdk), [sdk]);
+
+  const refresh = useCallback(async () => {
+    const page = await buckets.getFiles(bucketId, { folderId });
+    // render page.items (filter out f.isDirectory); loop cursor for full listings
+  }, [buckets, bucketId, folderId]);
+
+  return (
+    <MultiFileUpload
+      sdk={sdk}
+      bucketId={bucketId}
+      folderId={folderId}
+      path="uploads/"
+      accept=".pdf,.png,.jpg"
+      maxFileSizeInMb={10}
+      onUploadSuccess={refresh}
+      onUploadError={(e) => console.error('Upload failed:', e)} // surface in your UI
+    />
+  );
+}
+
+export default UploadPage;
+```
+
+Resolve a bucket id by name:
+
+```typescript
+const page = await new Buckets(sdk).getAll({ folderId });
+const bucket = page.items.find((b) => b.name === 'Invoices');
+```
+
+## Anti-patterns
+
+- **Do not hand-roll a multi-file upload loop over `Buckets.uploadFile()`** when this widget fits.
+- **Do not pass a folder GUID as `folderId`** — it is the numeric Orchestrator folder id.
+- **Do not wire only `onUploadSuccess`** — partial failures keep files in the list silently unless your app also reacts (`onUploadError` fires only when *all* files fail; per-file errors render inside the widget).
+- **Do not assume the callback means "all selected files uploaded"** — `uploadedFiles` may be a subset; compare against what the user selected if completeness matters.
+- **Do not ship with `OR.Buckets.Read`** — uploads need the full `OR.Buckets` scope.

package/skills/uipath-coded-apps/references/widgets/pdf-viewer.md

@@ -0,0 +1,122 @@
+# PDF Viewer Widget
+
+React PDF viewer for coded apps. Renders PDFs from **Orchestrator Storage Buckets**, **Data Fabric entity attachments**, or plain **URLs/Blobs** — toolbar (pagination, zoom, rotate, download), selectable text, password-protected PDFs, built-in loading/error states. Built on react-pdf (Mozilla pdf.js) with the worker **shipped inside the package** — no CDN, works behind the enterprise CSP on `*.uipath.host`.
+
+Package: [`@uipath/ui-widgets-pdf-viewer`](https://www.npmjs.com/package/@uipath/ui-widgets-pdf-viewer). Full prop/API surface lives in the package README — this file covers only the integration steps that are easy to get wrong inside a Coded App.
+
+> **Publish status:** this package is newer than the other widgets. Before recommending it, verify it resolves: `npm view @uipath/ui-widgets-pdf-viewer version`. On a 404 the package is not yet on the public registry — tell the user and fall back to the hand-rolled react-pdf pattern in [create-action-app.md § PDF viewer](../create-action-app.md#pdf-viewer-when-displaying-pdf-documents) rather than inventing an install path. Do **not** fall back to `<iframe>`/`<embed>`/`<object>` PDF tags — Action Center loads coded apps in a sandboxed iframe whose CSP blocks browser-native PDF rendering, and the react-pdf pattern works in web apps too.
+
+## When to Use
+
+- User asks to **display/preview a PDF** stored in a bucket, on a Data Fabric record, or behind a URL — e.g., the document pane beside an approval form in an action app.
+- Replaces hand-rolled react-pdf/pdf.js wiring (worker setup, fetch plumbing, toolbar, password prompts).
+- **Not for Document Understanding validation.** Review/correct DU extraction results → [validation-station.md](validation-station.md) (its viewer adds bounding boxes and field linkage). This widget is display-only.
+
+## Critical Rules
+
+1. **Peer versions are hard requirements.** `react >= 19.2.0`, `react-dom >= 19.2.0`, `@uipath/uipath-typescript >= 1.4.1`.
+2. **Import the stylesheet once**: `import '@uipath/ui-widgets-pdf-viewer/PdfViewer.css'`. Body needs `light` or `dark` class.
+3. **One `source` prop, four shapes — the fields you pass select the adapter.** `bucketId` → storage bucket, `entityId` → Data Fabric entity attachment, `url` → direct URL, `data` → pre-fetched `Blob`/`ArrayBuffer`.
+4. **Bucket sources scope the folder with EXACTLY ONE of** `folderId` (number), `folderKey` (GUID — what coded apps usually have), or `folderPath` (e.g. `"Shared/Finance"`).
+5. **`sdk` is required for `bucket`/`entity` sources** — pass the app's initialized instance from `useAuth()`. Missing sdk doesn't throw; the widget renders its own error card.
+6. **Required scopes:** bucket source → `OR.Buckets.Read` (or `OR.Buckets`); entity source → `DataFabric.Data.Read`. `url`/`data` sources need no scopes (for `url`, CORS/same-origin rules apply — the browser fetches it). See [../oauth-scopes.md](../oauth-scopes.md).
+7. **Never point pdf.js at a CDN worker.** The worker ships in the package and is version-locked to it; the platform CSP blocks external hosts anyway. Production builds need zero config — the worker is emitted as a same-origin asset. **Vite dev needs an `optimizeDeps` PAIR** (pre-bundling rewrites the widget's `import.meta.url` worker resolution):
+
+   ```typescript
+   optimizeDeps: {
+     // Keep the widget's import.meta.url intact so its packaged worker resolves.
+     exclude: ['@uipath/ui-widgets-pdf-viewer'],
+     // REQUIRED with the exclude: the widget imports react-pdf, whose ESM build
+     // imports CommonJS deps ('warning') that only interop when pre-bundled.
+     // Exclude alone blank-pages the app at module load:
+     // "does not provide an export named 'default'".
+     include: ['react-pdf'],
+   },
+   ```
+
+   Alternative (no exclude): override the worker once at app startup, after importing the widget:
+
+   ```typescript
+   import { pdfjs } from 'react-pdf';
+   pdfjs.GlobalWorkerOptions.workerSrc = new URL(
+     'pdfjs-dist/build/pdf.worker.min.mjs',
+     import.meta.url,
+   ).toString();
+   ```
+
+   Verify by rendering a PDF in dev AND in the built app — a green build does not prove the worker resolves.
+8. **Inline `source` object literals are safe.** The widget keys sources internally, so a new object per render does NOT retrigger fetches (the classic react-pdf `file`-prop identity trap is solved inside).
+9. **Non-Latin (CJK) PDFs may render blank glyphs** — v1 does not bundle pdf.js cMap assets. Warn the user if their documents are Chinese/Japanese/Korean.
+
+## Install
+
+From inside the scaffolded app directory (after the publish check above):
+
+```bash
+npm install @uipath/ui-widgets-pdf-viewer --@uipath:registry=https://registry.npmjs.org
+```
+
+Registry flag forces the public npm registry (skill default — users may have `@uipath` scoped to GitHub Packages).
+
+## Key Props
+
+| Prop | Required | Notes |
+|------|----------|-------|
+| `source` | Yes | `{ bucketId, folderId\|folderKey\|folderPath, path }` \| `{ entityId, recordId, fieldName }` \| `{ url }` \| `{ data }`. |
+| `sdk` | No* | *Required for bucket/entity sources. |
+| `toolbar` | No | Per-feature toggles `pagination`/`zoom`/`rotate`/`download` (all default `true`); disable all four to hide the toolbar. |
+| `fileName` | No | Toolbar label + download filename. |
+| `maxHeight` | No | Canvas max height (default `640`); the canvas scrolls internally — the widget fills its parent's width. |
+| `onLoadSuccess` | No | `({ numPages }) => void`. |
+| `onLoadError` | No | `(error) => void` — fetch or render failure (widget also shows its own error + Retry UI). |
+
+## Integration: Action App (document beside the form)
+
+Designed for a narrow split pane beside an approval form — fills its container, scrolls internally, failures stay inside the widget's box:
+
+```typescript
+import { PdfViewer } from '@uipath/ui-widgets-pdf-viewer';
+import '@uipath/ui-widgets-pdf-viewer/PdfViewer.css';
+import { sdk } from '../uipath'; // action app: new UiPath() with host-injected session
+
+function DocumentPane({ folderKey, path }: { folderKey: string; path: string }) {
+  return (
+    <PdfViewer
+      sdk={sdk}
+      source={{ bucketId: 123, folderKey, path }}
+      fileName={path.split('/').pop()}
+      maxHeight="100%"
+    />
+  );
+}
+```
+
+Action apps get `folderId` from `codedActionAppService.getTask()` — `source={{ bucketId, folderId, path }}` works equally; pass whichever folder identifier you already have (rule 4).
+
+## Integration: Web App
+
+```typescript
+import { PdfViewer } from '@uipath/ui-widgets-pdf-viewer';
+import '@uipath/ui-widgets-pdf-viewer/PdfViewer.css';
+import { useAuth } from '../hooks/useAuth';
+
+function InvoiceViewer({ entityId, recordId }: { entityId: string; recordId: string }) {
+  const { sdk } = useAuth();
+
+  return (
+    <PdfViewer
+      sdk={sdk}
+      source={{ entityId, recordId, fieldName: 'InvoicePdf' }}
+      onLoadError={(e) => console.error('PDF failed:', e)} // widget shows its own error card + Retry
+    />
+  );
+}
+```
+
+## Anti-patterns
+
+- **Do not configure a CDN `workerSrc`** — CSP blocks it and versions drift; the packaged worker is the supported path.
+- **Do not fetch the PDF yourself for bucket/entity sources** — pass the source descriptor; the widget resolves the read-URI/attachment. If you already hold bytes from another flow, pass them as `{ data }`.
+- **Do not use this widget for DU validation review** — that is [validation-station.md](validation-station.md); this one has no bounding boxes or field editing.
+- **Do not pass two folder identifiers in a bucket source** — exactly one of `folderId`/`folderKey`/`folderPath`.
+- **Do not wrap the viewer in your own loading/error/password UI** — loading, error-with-Retry, empty, and password-prompt states are built in; wire `onLoadError` for logging/telemetry, not for rendering a duplicate error screen.

package/skills/uipath-coded-apps/references/widgets/validation-station.md

@@ -17,7 +17,7 @@ If the user just wants a generic form (no DU document), use the standard Action
 ## Critical Rules
 
 1. **Peer versions are hard requirements.** Widget requires `react >= 19.2.0`, `react-dom >= 19.2.0`, `@uipath/uipath-typescript >= 1.4.1`. The Vite scaffold pins React 19.2+, but verify in `package.json` before installing.
-2. **The widget's web component loads its CSS, fonts, and assets at runtime, not at build time.** So `vite.config.ts` must *copy* those files next to the build output (for prod) and *serve them as raw CSS* in dev — use the config under "Static Assets" below. Skip it and you get 404s for PDF/fonts/styling in prod, or icons that render as their names (`warning`, `error`, `circle`) in dev. A green `npm run build` hides both — run the app to confirm.
+2. **The widget's web component loads its CSS, fonts, and assets at runtime, not at build time.** So `vite.config.ts` must *copy* those files next to the build output (for prod) and *serve them as raw CSS* in dev — use the config under "Static Assets" below. Skip it and most of prod degrades *quietly*: PDF rendering, translations, and styling 404 in the background, and fonts are silently absent even when `fonts.css` itself loads (the font files it references live in `media/`). **Business-rules validation is the exception — it errors outright** (its executor is dynamically `import()`ed from `du-assets/`), so a business-rules error in an app that otherwise renders fine usually means `du-assets/` is missing from the deployment. In dev the tell is icons rendering as their names (`warning`, `error`, `circle`). A green `npm run build` hides all of this — run the app to confirm.
 3. **Set `optimizeDeps.exclude: ['@uipath/du-validation-station-wc']` in `vite.config.ts`.** Vite's pre-bundler rewrites `import.meta.url` and breaks runtime asset resolution.
 4. **Body needs `light` or `dark` class** for theming. Match it to the `theme` prop. Action apps already manage this via `onInitTheme` from `CodedActionAppService.getTask()`.
 5. **`sdk` must already be initialized.** Pass the same `UiPath` instance produced by `useAuth()` (web app) or constructed in `src/uipath.ts` (action app). Do not construct a second SDK just for the widget — auth state will diverge.

package/skills/uipath-functions/SKILL.md

@@ -72,6 +72,14 @@ uip function new <name> --language js       # JavaScript Function (JS/TS, no job
 
 `--empty` skips the hello-world function (JS/TS only).
 
+**The scaffold follows the installed packages.** With a framework package present in the environment (`uipath-langchain`, `llama-index`, `openai-agents`), `uip function new -l py` emits that framework's **agent** scaffold — `langgraph.json` plus an LLM `main.py` — not a function scaffold. Expected behaviour, not a broken flag. Recovery, in one pass:
+
+1. Delete the framework config (`langgraph.json` and equivalents).
+2. Replace `main.py` with the function template (Step 3).
+3. Keep `pyproject.toml`'s `[project]` metadata (Step 5) — swap `dependencies` for what the function needs.
+
+Do not re-run `new` with different flag spellings, and do not read CLI or SDK internals to explain the scaffold. Reshape the project and move on.
+
 ### Step 2: Define Function Schema
 
 Use typed I/O. The SDK accepts pydantic `BaseModel`, `pydantic.dataclasses.dataclass`, a stdlib `@dataclass`, or a thin class with typed annotations. The shipped samples favor **pydantic** (`BaseModel` in csv-processor, `pydantic.dataclasses.dataclass` in calculator/greeter):
@@ -161,6 +169,7 @@ The key is the entrypoint name — it can be any string and marks this as the ca
 name = "my-function"
 version = "0.1.0"
 description = "..."
+authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.11"
 dependencies = [
     "uipath",
@@ -169,6 +178,8 @@ dependencies = [
 ]
 ```
 
+`authors` is **required** — without it `uip function pack` rejects the package with `Project authors cannot be empty`.
+
 No `[build-system]` section. The project is identified as a Coded Function by the `functions` map in `uipath.json` (Step 4).
 
 ### Step 6: Generate Entry Points