@agent-native/core 0.76.5 → 0.76.6

package/corpus/core/docs/content/locales/hi-IN/security.md

@@ -0,0 +1,330 @@
+---
+title: "सुरक्षा"
+description: "एजेंट-नेटिव ऐप्स के लिए सुरक्षा मॉडल: इनपुट सत्यापन, SQL इंजेक्शन रोकथाम, XSS, डेटा स्कोपिंग, रहस्य प्रबंधन और प्रमाणीकरण पैटर्न।"
+---
+
+# सुरक्षा
+
+एजेंट-नेटिव ऐप्स डिफ़ॉल्ट रूप से सुरक्षित होने के लिए डिज़ाइन किए गए हैं। फ्रेमवर्क कई परतों पर स्वचालित सुरक्षा प्रदान करता है - आपको बॉक्स से बाहर SQL-स्तर डेटा अलगाव, पैरामीटरयुक्त क्वेरी, इनपुट सत्यापन और प्रमाणीकरण मिलता है।
+
+## आपको मुफ़्त में क्या मिलता है, और आपके पास क्या है {#what-you-own}
+
+```an-diagram title="Defense in layers" summary="The framework owns most of the threat surface; you own two things — tagging tables for scoping and validating external input."
+{
+  "html": "<div class=\"sec-layers\"><div class=\"diagram-card free\"><span class=\"diagram-pill ok\">Framework owns</span><small class=\"diagram-muted\">SQL isolation &middot; parameterized queries &middot; XSS escaping &middot; auth guard &middot; CSRF cookies &middot; secret encryption</small></div><div class=\"diagram-card you\"><span class=\"diagram-pill warn\">You own</span><small class=\"diagram-muted\">A. tag tables with ownableColumns() &amp; route through access guards<br>B. give every action a Zod schema &amp; send user URLs through the SSRF guard</small></div></div>",
+  "css": ".sec-layers{display:flex;flex-direction:column;gap:12px}.sec-layers .diagram-card{display:flex;flex-direction:column;gap:6px;padding:14px 16px}"
+}
+```
+
+जब आप मानक पैटर्न पर निर्माण करते हैं, तो ढांचा पहले से ही आपके लिए अधिकांश खतरे की सतह को संभाल लेता है:
+
+- **डेटा अलगाव** - एजेंट SQL को फिर से लिखा गया है ताकि यह केवल वर्तमान उपयोगकर्ता (और सक्रिय संगठन) की पंक्तियों को देख सके। [Data Scoping](#data-scoping) देखें.
+- **SQL इंजेक्शन** - `db-query`/`db-exec` और Drizzle हमेशा पैरामीटराइज़ करते हैं। [SQL Injection Prevention](#sql-injection) देखें.
+- **XSS** - React ऑटो-एस्केप, टिपटैप और `react-markdown` सैनिटाइज़। [XSS Prevention](#xss) देखें.
+- **प्रामाणिक और CSRF** - प्रत्येक `defineAction` प्रामाणिक-संरक्षित है; कुकीज़ `httpOnly` + `SameSite=lax` हैं। [Authentication](#auth) देखें.
+- **गुप्त एन्क्रिप्शन** - क्रेडेंशियल्स और वॉल्ट बाकी समय एन्क्रिप्टेड होते हैं। [Secrets Management](#secrets) देखें.
+
+यह एक छोटी सी सतह छोड़ता है जिसके बारे में आपको वास्तव में सोचना होगा:
+
+- **ए. स्कोपिंग के लिए अपनी तालिकाओं को टैग करें। ** [`ownableColumns()`](#data-scoping) के माध्यम से `owner_email` (और टीम डेटा के लिए `org_id`) जोड़ें, और Drizzle को [access guards](#access-guards) के माध्यम से पढ़ने/लिखने के लिए रूट करें।
+- **बी. बाहरी इनपुट को सत्यापित और रूट करें। ** प्रत्येक क्रिया को Zod [`schema:`](#input-validation) दें, और [SSRF guard](#ssrf) के माध्यम से उपयोगकर्ता/एजेंट URL के किसी भी सर्वर-साइड फ़ेच को भेजें।
+
+उन दोनों को ठीक कर लें और बाकी सब डिफ़ॉल्ट है। [Production Checklist](#production-checklist) आपके शिपमेंट से पहले एक पेज की पुष्टि है।
+
+## डिज़ाइन द्वारा सुरक्षा {#secure-by-design}
+
+जब आप मानक पैटर्न का उपयोग करते हैं तो फ्रेमवर्क आर्किटेक्चर सामान्य कमजोरियों को रोकता है:
+
+| भेद्यता        | फ़्रेमवर्क सुरक्षा                                                                              |
+| -------------- | ----------------------------------------------------------------------------------------------- |
+| SQL इंजेक्शन   | `db-query`/`db-exec` और Drizzle ORM में पैरामीटरयुक्त क्वेरीज़                                  |
+| XSS            | React ऑटो-एस्केप JSX; टिपटैप रिच टेक्स्ट को सैनिटाइज़ करता है                                   |
+| डेटा लीक       | अस्थायी दृश्यों के माध्यम से SQL-स्तरीय स्कोपिंग (`owner_email`, `org_id`)                      |
+| ऑथ बाइपास      | ऑथ गार्ड सभी `defineAction` एंडपॉइंट्स की स्वतः सुरक्षा करता है                                 |
+| इनपुट इंजेक्शन | `defineAction` में Zod स्कीमा सत्यापन                                                           |
+| CSRF           | `SameSite=lax` + `httpOnly` कुकीज़                                                              |
+| गुप्त प्रदर्शन | `.env` gitignored; क्रेडेंशियल और वॉल्ट विश्राम के समय एन्क्रिप्टेड (AES-256-GCM)               |
+| SSRF           | `ssrfSafeFetch` आंतरिक/मेटाडेटा लक्ष्यों को अवरुद्ध करता है + रीडायरेक्ट रीबाइंडिंग को रोकता है |
+
+## इनपुट सत्यापन {#input-validation}
+
+प्रत्येक क्रिया के लिए Zod `schema:` के साथ `defineAction` का उपयोग करें। आपका कोड चलने से पहले फ्रेमवर्क स्वचालित रूप से इनपुट को मान्य करता है:
+
+```ts
+import { z } from "zod";
+import { defineAction } from "@agent-native/core/action";
+
+export default defineAction({
+  description: "Create a note",
+  schema: z.object({
+    title: z.string().min(1).max(200).describe("Note title"),
+    content: z.string().optional().describe("Note body"),
+  }),
+  run: async (args) => {
+    // args is guaranteed valid — invalid input never reaches here
+  },
+});
+```
+
+अमान्य इनपुट स्पष्ट त्रुटि संदेश देता है (HTTP के लिए 400, एजेंट कॉल के लिए संरचित त्रुटि)। लीगेसी `parameters:` प्रारूप कोई रनटाइम सत्यापन प्रदान नहीं करता है।
+
+## SQL इंजेक्शन रोकथाम {#sql-injection}
+
+फ्रेमवर्क के `db-query` और `db-exec` उपकरण पैरामीटरयुक्त प्रश्नों का उपयोग करते हैं। उपयोगकर्ता इनपुट को तर्क के रूप में पारित किया जाता है, कभी भी SQL स्ट्रिंग में प्रक्षेपित नहीं किया जाता है:
+
+```ts
+// SAFE — parameterized query (framework default)
+await exec({ sql: "INSERT INTO notes (title) VALUES (?)", args: [title] });
+
+// SAFE — Drizzle ORM (always generates parameterized queries)
+await db.insert(notes).values({ title, ownerEmail: email });
+
+// DANGEROUS — string concatenation (never do this)
+await exec(`INSERT INTO notes (title) VALUES ('${title}')`);
+```
+
+```an-callout
+{
+  "tone": "risk",
+  "body": "Never build SQL by string concatenation or template literals. Pass user input as `args` to `exec` / `db-query`, or use Drizzle — both always parameterize. The `pnpm guards` checks catch unscoped and concatenated queries at CI time."
+}
+```
+
+## XSS रोकथाम {#xss}
+
+React सभी JSX अभिव्यक्तियों को स्वतः समाप्त कर देता है। अतिरिक्त दिशानिर्देश:
+
+- उपयोगकर्ता-नियंत्रित सामग्री के साथ कभी भी `dangerouslySetInnerHTML` का उपयोग न करें
+- कभी भी `innerHTML`, `eval()`, या `document.write()` का उपयोग न करें
+- रिच टेक्स्ट संपादन के लिए, टिपटैप (फ्रेमवर्क निर्भरता) का उपयोग करें - यह अपनी स्कीमा के माध्यम से स्वच्छ करता है
+- मार्कडाउन प्रस्तुत करने के लिए, `react-markdown` का उपयोग करें - यह सुरक्षित रूप से React तत्वों में परिवर्तित हो जाता है
+
+## सर्वर-साइड फ़ेच (SSRF) {#ssrf}
+
+उपयोगकर्ता या एजेंट-नियंत्रित URL के किसी भी सर्वर-साइड `fetch` को फ्रेमवर्क SSRF गार्ड से गुजरना होगा, या इसे क्लाउड मेटाडेटा (`169.254.169.254`), `localhost`, या आंतरिक सेवाओं पर इंगित किया जा सकता है:
+
+```ts
+import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
+
+const res = await ssrfSafeFetch(userProvidedUrl, {}, { maxRedirects: 3 });
+```
+
+`ssrfSafeFetch` निजी/आंतरिक लक्ष्यों को ब्लॉक करता है, कनेक्ट समय पर हल किए गए आईपी को दोबारा जांचता है (DNS रीबाइंडिंग), और प्रत्येक रीडायरेक्ट हॉप को दोबारा सत्यापित करता है ताकि सार्वजनिक URL निजी नेटवर्क में रीडायरेक्ट न हो सके। एक्सटेंशन आईफ्रेम प्रॉक्सी, `upload-image`, और डिज़ाइन-टोकन आयातक इसके माध्यम से सभी रूट करते हैं। केवल-उड़ान-पूर्व जांच के लिए, `redirect: "manual"` के साथ `isBlockedExtensionUrlWithDns(url)` का उपयोग करें।
+
+## डेटा स्कोपिंग {#data-scoping}
+
+उत्पादन में, फ्रेमवर्क स्वचालित रूप से एजेंट SQL क्वेरी को वर्तमान उपयोगकर्ता के डेटा तक सीमित कर देता है। इसे SQL स्तर पर लागू किया जाता है - एजेंट इसे बायपास नहीं कर सकते। यह अनुभाग स्कोपिंग पाइपलाइन के लिए विहित संदर्भ है; यांत्रिकी के लिए [Authentication](/docs/authentication) और [Multi-Tenancy](/docs/multi-tenancy) दस्तावेज़ यहां लिंक हैं।
+
+### स्कोपिंग पाइपलाइन {#scoping-pipeline}
+
+स्कोपिंग प्रमाणित सत्र से एजेंट द्वारा चलाए जाने वाले SQL तक प्रवाहित होती है:
+
+```
+session.orgId → AGENT_ORG_ID → SQL row scoping
+```
+
+```an-diagram title="The scoping pipeline" summary="Agent SQL never touches base tables directly — it reads through a temporary view scoped to the current identity, so a bare table name can only return owned rows."
+{
+  "html": "<div class=\"scope-pipe\"><div class=\"diagram-node\">Signed-in session<br><small class=\"diagram-muted\">email &middot; orgId</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\">Request context<br><small class=\"diagram-muted\">AGENT_ORG_ID</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\">Temporary VIEW<br><small class=\"diagram-muted\">WHERE owner_email = ? AND org_id = ?</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node ok\">Agent SQL<br><small class=\"diagram-muted\">bare table names only</small></div></div>",
+  "css": ".scope-pipe{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.scope-pipe .diagram-node{display:flex;flex-direction:column;gap:2px;padding:10px 14px}.scope-pipe .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+साइन-इन सत्र में `email` और (जब कोई संगठन सक्रिय होता है) `orgId` होता है। फ़्रेमवर्क उस सत्र से अनुरोध संदर्भ स्थापित करता है, सक्रिय संगठन को एजेंट SQL को `AGENT_ORG_ID` के रूप में उजागर करता है, और प्रत्येक क्वेरी को फिर से लिखता है ताकि यह केवल उन पंक्तियों को देख सके जिनके पास वर्तमान पहचान है। चाहे क्वेरी UI, एक क्रिया, या एजेंट से आती हो, वही पथ लागू होता है - एजेंट उस संगठन के लिए डेटा नहीं पढ़ सकता है जिसका उपयोगकर्ता सदस्य नहीं है।
+
+### प्रति-उपयोगकर्ता स्कोपिंग (`owner_email`)
+
+उपयोगकर्ता-विशिष्ट डेटा वाली प्रत्येक तालिका में एक `owner_email` टेक्स्ट कॉलम होना चाहिए। CamelCase Drizzle संपत्ति नाम का उपयोग करें - `accessFilter` `resourceTable.ownerEmail` पढ़ता है:
+
+```ts
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+} from "@agent-native/core/db/schema";
+
+// Minimal: just the owner column
+export const notes = table("notes", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  content: text("content"),
+  ownerEmail: text("owner_email").notNull(), // REQUIRED — camelCase property
+});
+
+// Or use ownableColumns() to add owner_email + org_id + visibility in one call
+export const notes = table("notes", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  content: text("content"),
+  ...ownableColumns(),
+});
+```
+
+फ़्रेमवर्क अस्थायी SQL दृश्य बनाता है जो क्वेरीज़ को स्वचालित रूप से फ़िल्टर करता है:
+
+```sql
+CREATE TEMPORARY VIEW "notes" AS
+  SELECT * FROM main."notes"
+  WHERE "owner_email" = 'alice@example.com';
+```
+
+जब कॉलम पहले से मौजूद नहीं है तो INSERT स्टेटमेंट `owner_email` ऑटो-इंजेक्ट हो जाते हैं।
+
+`db-query` / `db-exec` उपकरण स्कीमा-योग्य तालिका संदर्भों (`public.<table>`, `main.<table>`) को अस्वीकार करते हैं - एक योग्य नाम आधार तालिका में हल हो जाता है और उपरोक्त अस्थायी दृश्य को बायपास कर देगा। एजेंट नंगे टेबल नामों का उपयोग करते हैं; स्कोपिंग स्वचालित रूप से लागू होती है।
+
+### प्रति-संगठन स्कोपिंग (`org_id`)
+
+बहु-उपयोगकर्ता ऐप्स के लिए जहां टीमें डेटा साझा करती हैं, एक `org_id` कॉलम जोड़ें। जब दोनों कॉलम मौजूद होते हैं, तो प्रश्नों का दायरा दोनों द्वारा होता है: `WHERE owner_email = ? AND org_id = ?`.
+
+`ownableColumns()` स्कीमा सहायक एक कॉल में `owner_email`, `org_id`, और `visibility` जोड़ता है, इसलिए नई किरायेदार-जागरूक तालिकाओं को डिफ़ॉल्ट रूप से पूर्ण स्कोपिंग अनुबंध मिलता है:
+
+```ts
+import { table, text, ownableColumns } from "@agent-native/core/db/schema";
+
+export const projects = table("projects", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  ...ownableColumns(), // adds owner_email + org_id + visibility
+});
+```
+
+```an-schema title="What ownableColumns() adds" summary="The three columns that make a table tenant-aware and shareable."
+{
+  "entities": [
+    {
+      "id": "ownable",
+      "name": "ownable resource",
+      "note": "Any table that spreads ...ownableColumns()",
+      "fields": [
+        { "name": "owner_email", "type": "text", "nullable": false, "note": "Creator. Auto-filled by write actions; auto-injected on INSERT." },
+        { "name": "org_id", "type": "text", "nullable": true, "note": "Owner's active org at creation. Drives org-visibility checks." },
+        { "name": "visibility", "type": "enum", "nullable": false, "note": "private | org | public — coarse default, defaults to private." }
+      ]
+    }
+  ]
+}
+```
+
+### actions में एक्सेस गार्ड {#access-guards}
+
+रॉ एजेंट SQL ऊपर दिए गए अस्थायी दृश्यों के दायरे में है। एक्शन कोड जो Drizzle के साथ क्वेरी करता है, उसे सीधे फ्रेमवर्क के एक्सेस हेल्पर्स के माध्यम से जाना चाहिए ताकि पढ़ना और लिखना वर्तमान पहचान के दायरे में रहे:
+
+- **`accessFilter`** - `WHERE` विधेय लौटाता है जो किसी क्वेरी को उन पंक्तियों तक सीमित करता है जिन्हें वर्तमान उपयोगकर्ता/संगठन देख सकता है। इसे सूची/पठित प्रश्नों में उपयोग करें।
+- **`resolveAccess`** - वर्तमान अनुरोध के लिए प्रभावी पहुंच दायरे (मालिक, संगठन, साझा) को हल करता है।
+- **`assertAccess`** - एक लेखन या एकल-रिकॉर्ड पढ़ने की सुरक्षा करता है, यदि वर्तमान पहचान लक्ष्य पंक्ति पर कार्य नहीं कर सकती है, तो उसे फेंक देता है।
+
+`ownableColumns()` के साथ निर्मित तालिकाओं को इन स्कोप्ड रीड और राइट की आवश्यकता होती है; कस्टम Nitro मार्गों को स्वामित्व योग्य डेटा की क्वेरी करने से पहले अनुरोध संदर्भ स्थापित करना होगा। `guard-no-unscoped-queries` चेक (`pnpm guards` के माध्यम से चलाया गया) इसे CI समय पर लागू करता है। पूर्ण सहायक API के लिए `sharing` कौशल देखें।
+
+### सत्यापन
+
+```bash
+pnpm action db-check-scoping           # Check all tables have owner_email
+pnpm action db-check-scoping --require-org  # Also require org_id
+```
+
+## रहस्य प्रबंधन {#secrets}
+
+| गुप्त प्रकार                                | कहां स्टोर करें                                                       |
+| ------------------------------------------- | --------------------------------------------------------------------- |
+| तैनाती-स्तर कुंजियाँ (प्रति ऐप एक)          | `.env` फ़ाइल (gitignored, केवल सर्वर-साइड)                            |
+| प्रति-उपयोगकर्ता / प्रति-संगठन API कुंजियाँ | `saveCredential` / `resolveCredential` (बाकी स्थिति में एन्क्रिप्टेड) |
+| पंजीकृत रहस्य (साइडबार वॉल्ट)               | `app_secrets` वॉल्ट (बाकी स्थिति में एन्क्रिप्टेड)                    |
+| OAuth टोकन (Google, GitHub)                 | `saveOAuthTokens()` के माध्यम से `oauth_tokens` स्टोर                 |
+| सत्र टोकन                                   | स्वचालित (बेहतर प्रमाणीकरण इसे संभालता है)                            |
+
+प्रति-उपयोगकर्ता/प्रति-संगठन क्रेडेंशियल्स और वॉल्ट को AES-256-GCM के साथ एन्क्रिप्ट किया गया है, जो `SECRETS_ENCRYPTION_KEY` द्वारा कुंजीबद्ध है (`BETTER_AUTH_SECRET` पर वापस आते हुए); इसके बिना उत्पादन शुरू होने से इंकार कर दिया जाता है। किसी भी पहले से मौजूद प्लेनटेक्स्ट क्रेडेंशियल पंक्तियों को एन्क्रिप्ट करने के लिए, `pnpm action db-migrate-encrypt-credentials` (निष्क्रिय, गैर-विनाशकारी) चलाएँ।
+
+`settings`, `application_state`, स्रोत कोड, या कार्रवाई प्रतिक्रियाओं में कभी भी रहस्य संग्रहीत न करें। उपरोक्त क्रेडेंशियल / वॉल्ट APIs का उपयोग करें - वे एन्क्रिप्शन और प्रति-उपयोगकर्ता स्कोपिंग दोनों को संभालते हैं।
+
+## प्रमाणीकरण {#auth}
+
+प्रमाणीकरण स्वचालित है. पूर्ण सेटअप के लिए [Authentication](/docs/authentication) दस्तावेज़ देखें।
+
+**सुरक्षा के लिए मुख्य बिंदु:**
+
+- `defineAction` एंडपॉइंट ऑथ गार्ड द्वारा स्वतः-संरक्षित हैं
+- कस्टम `/api/` मार्गों को `getSession(event)` पर कॉल करना होगा और परिणाम की जांच करनी होगी
+- राज्य-परिवर्तन संचालन को POST (actions के लिए डिफ़ॉल्ट) का उपयोग करना चाहिए
+- `SameSite=lax` + `httpOnly` कुकीज़ अधिकांश CSRF हमलों को रोकती हैं
+
+## A2A पहचान सत्यापन {#a2a-identity}
+
+जब ऐप्स A2A प्रोटोकॉल के माध्यम से एक-दूसरे को कॉल करते हैं, तो वे एक साझा रहस्य के साथ हस्ताक्षरित JWT टोकन का उपयोग करके पहचान सत्यापित करते हैं:
+
+```bash
+A2A_SECRET=your-shared-secret-at-least-32-chars
+```
+
+1. ऐप A एक JWT पर हस्ताक्षर करता है जिसमें `sub: "steve@example.com"` होता है
+2. ऐप B उसी रहस्य से JWT हस्ताक्षर को सत्यापित करता है
+3. ऐप बी सत्यापित `sub` दावे को अनुरोध संदर्भ में पढ़ता है
+4. डेटा स्कोपिंग लागू होती है - ऐप बी केवल स्टीव का डेटा दिखाता है
+
+उत्पादन में `A2A_SECRET` के बिना, प्रत्येक A2A एंडपॉइंट और `/_agent-native/integrations/process-task` सेल्फ-फायर एंडपॉइंट रिटर्न **503**। इसे हर उस ऐप पर सेट करें जो A2A ट्रैफ़िक कॉल करता है या प्राप्त करता है। (स्थानीय विकास के लिए ढांचा अभी भी अप्रमाणित कॉल की अनुमति देता है।)
+
+## इनबाउंड Webhooks {#webhooks}
+
+इनबाउंड वेबहुक हैंडलर (रीसेंड, सेंडग्रिड, Slack, टेलीग्राम, व्हाट्सएप, रिकॉल.एआई, डीपग्राम, ज़ूम, गूगल डॉक्स पब/सब) उत्पादन में डिफ़ॉल्ट रूप से जाली अनुरोधों को अस्वीकार कर देते हैं: जब संबंधित हस्ताक्षरित गुप्त एनवी संस्करण गायब होता है, तो हैंडलर स्वीकार करने और भेजने के बजाय 401 लौटाता है।
+
+यह पहले एक "चेतावनी देने और स्वीकार करने" का रुख था - उस रहस्य को सेट करें जिसे आप अन्यथा अनदेखा कर देंगे, या केवल स्थानीय विकास के लिए `AGENT_NATIVE_ALLOW_UNVERIFIED_WEBHOOKS=1` के साथ पुराने व्यवहार में वापस आने का विकल्प चुनें। प्रति-एकीकरण हस्ताक्षर-गुप्त चर के लिए [Messaging](/docs/messaging#env-vars) देखें।
+
+## उत्पादन चेकलिस्ट {#production-checklist}
+
+### प्रामाणिक एवं रहस्य
+
+- [ ] `BETTER_AUTH_SECRET` को एक यादृच्छिक 32+ चार स्ट्रिंग (`openssl rand -hex 32`) पर सेट किया गया है, जब तक कि यह एक होस्टेड वर्कस्पेस तैनाती नहीं है जो इसे `A2A_SECRET` से प्राप्त करता है
+- [ ] `OAUTH_STATE_SECRET` को एक अलग यादृच्छिक 32+ चार स्ट्रिंग पर सेट करें (`BETTER_AUTH_SECRET` का पुन: उपयोग न करें) - [OAuth State Signing](#oauth-state) देखें
+- [ ] `A2A_SECRET` प्रत्येक ऐप पर सेट होता है जो कॉल करता है या A2A ट्रैफ़िक प्राप्त करता है - [A2A Identity Verification](#a2a-identity) देखें
+- [ ] `SECRETS_ENCRYPTION_KEY` सेट (या `BETTER_AUTH_SECRET` फ़ॉलबैक पर भरोसा करें) - [Secrets Management](#secrets) देखें
+- [ ] `AUTH_SKIP_EMAIL_VERIFICATION` उत्पादन में **नहीं** सेट है (या केवल QA पूर्वावलोकन परिनियोजन पर सेट है)
+
+### वेबहुक रहस्य (आपके द्वारा उपयोग किए जाने वाले एकीकरण के लिए सेट करें)
+
+- [ ] प्रत्येक सक्षम इनबाउंड एकीकरण के लिए हस्ताक्षरित गुप्त सेट - प्रति-एकीकरण सूची के लिए [Inbound Webhooks](#webhooks) और [Messaging](/docs/messaging#env-vars) देखें
+- [ ] `AGENT_NATIVE_ALLOW_UNVERIFIED_WEBHOOKS` उत्पाद में **नहीं** सेट है
+
+### स्कीमा
+
+- [ ] प्रत्येक उपयोगकर्ता-सामना वाली तालिका में `owner_email` है, बहु-उपयोगकर्ता तालिकाओं में भी `org_id` है - [Data Scoping](#data-scoping) देखें
+- [ ] ओनेबल-टेबल रीड/राइट [access guards](#access-guards) के माध्यम से होता है
+- [ ] सभी actions Zod `schema:` के साथ `defineAction` का उपयोग करते हैं - [Input Validation](#input-validation) देखें
+- [ ] उपयोगकर्ता/एजेंट URLs के सर्वर-साइड फ़ेच `ssrfSafeFetch` के माध्यम से जाते हैं - [SSRF](#ssrf) देखें
+- [ ] उपयोगकर्ता सामग्री के साथ कोई `dangerouslySetInnerHTML` नहीं (या आउटपुट DOMPurify के माध्यम से चलाया जाता है)
+- [ ] कोई स्ट्रिंग-संबद्ध SQL
+- [ ] `pnpm guards` साफ़ है (`guard-no-unscoped-queries`, `guard-no-env-credentials`, `guard-no-env-mutation`, `guard-no-localhost-fallback`, `guard-no-unscoped-credentials`, `guard-no-drizzle-push`)
+- [ ] डेटा अलगाव को सत्यापित करने के लिए दो उपयोगकर्ता खातों के साथ परीक्षण किया गया
+
+### विविध सख्तीकरण
+
+- [ ] `AGENT_NATIVE_DEBUG_ERRORS` वास्तविक उत्पाद में **नहीं** सेट है (केवल डिबग पूर्वावलोकन पर)
+- [ ] `AGENT_NATIVE_KEYS_WORKSPACE_FALLBACK` तब तक **नहीं** सेट है जब तक कि आपका संगठन वास्तव में कार्यस्थान कुंजी साझा नहीं करता है - [Cross-User Tooling Secrets](#tooling-secrets) देखें
+- [ ] बहु-किरायेदार तैनाती में, **उपयोगकर्ता अपना स्वयं का `ANTHROPIC_API_KEY`** लाते हैं - ढांचा तैनाती-स्तर के एनवी संस्करण पर वापस आने से इंकार कर देता है
+
+---
+
+नीचे दिए गए अनुभाग आला पर्यावरण फ़्लैग को कवर करते हैं जिन तक आप केवल विशिष्ट परिनियोजन में पहुंचते हैं। अधिकांश ऐप्स उन्हें कभी नहीं छूते.
+
+## OAuth राज्य हस्ताक्षर {#oauth-state}
+
+OAuth प्रवाह (Google, एटलसियन, ज़ूम) एक समर्पित HMAC कुंजी के साथ अपने राज्य लिफाफे पर हस्ताक्षर करते हैं:
+
+```bash
+OAUTH_STATE_SECRET=$(openssl rand -hex 32)
+```
+
+यह `GOOGLE_CLIENT_SECRET` (Google के साथ साझा किया गया एक क्रेडेंशियल) पर वापस आता था - Google रहस्य के लीक होने से हमलावरों को OAuth राज्य लिफाफे बनाने की अनुमति मिल जाती। समर्पित कुंजी किसी भी तीसरे पक्ष के रहस्य से स्वतंत्र है। यदि `OAUTH_STATE_SECRET` अनसेट है, तो फ्रेमवर्क वापस `BETTER_AUTH_SECRET` पर आ जाता है; होस्ट किए गए कार्यक्षेत्र परिनियोजन पहले से आवश्यक `A2A_SECRET` से प्रति-उद्देश्य OAuth कुंजी भी प्राप्त कर सकते हैं। यदि उन सर्वर रहस्यों में से कोई भी उपलब्ध नहीं है, तो OAuth प्रवाह उत्पादन में विफल हो जाता है।
+
+`redirect_uri` क्वेरी पैरामीटर को एक अनुमति सूची (समान मूल + फ्रेमवर्क `/_agent-native/...` पथ) के विरुद्ध भी मान्य किया जाता है। टेम्प्लेट में कस्टम OAuth प्रवाह को राज्य पर हस्ताक्षर करने से पहले फ्रेमवर्क के `isAllowedOAuthRedirectUri()` हेल्पर का उपयोग करना चाहिए।
+
+## क्रॉस-यूज़र टूलींग रहस्य {#tooling-secrets}
+
+`${keys.NAME}` को संदर्भित करने वाले उपकरण और ऑटोमेशन डिफ़ॉल्ट रूप से प्रति-उपयोगकर्ता रहस्यों को हल करते हैं। इस संस्करण में वर्कस्पेस-स्कोप फ़ॉलबैक **डिफ़ॉल्ट रूप से बंद** है - एक दुर्भावनापूर्ण संगठन सदस्य अन्यथा वर्कस्पेस `OPENAI_API_KEY` प्लांट कर सकता है और अन्य सदस्यों की API कॉल काट सकता है।
+
+यदि आपका संगठन वास्तव में कार्यस्थान-व्यापी कुंजियाँ साझा करता है (उदाहरण के लिए एकल कॉर्पोरेट स्ट्राइप कुंजी), तो पुराने व्यवहार में वापस आने का विकल्प चुनें:
+
+```bash
+AGENT_NATIVE_KEYS_WORKSPACE_FALLBACK=1
+```
+
+वर्कस्पेस-स्कोप गुप्त लेखन के लिए इस ध्वज की परवाह किए बिना अभी भी संगठन स्वामी/व्यवस्थापक भूमिका की आवश्यकता होती है।

package/corpus/core/docs/content/locales/hi-IN/server.md

@@ -0,0 +1,253 @@
+---
+title: "सर्वर"
+description: "Nitro सर्वर रूट, प्लगइन्स, फ्रेमवर्क-माउंटेड रूट, अनुरोध संदर्भ, और SQL-समर्थित सिंक।"
+---
+
+# सर्वर
+
+एजेंट-नेटिव ऐप्स सर्वर रूट और प्लगइन्स के लिए [Nitro](https://nitro.build) का उपयोग करते हैं। अधिकांश उत्पाद व्यवहार [Actions](/docs/actions) में रहना चाहिए; कस्टम रूट उन प्रोटोकॉल सतहों के लिए हैं जो actions में फिट नहीं होते हैं: अपलोड, स्ट्रीमिंग, सार्वजनिक पेज, webhooks, OAuth कॉलबैक और प्रदाता-विशिष्ट APIs।
+
+```an-diagram title="What runs on the server" summary="Actions are the default. Custom file routes and framework-mounted routes share the same Nitro app and the same SQL database."
+{
+  "html": "<div class=\"diagram-server\"><div class=\"diagram-col entry\"><div class=\"diagram-node\">Browser / UI</div><div class=\"diagram-node\">Agent loop</div><div class=\"diagram-node\">External clients<br><small class=\"diagram-muted\">HTTP · MCP · A2A</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel\" data-rough><strong>Nitro server</strong><div class=\"diagram-row\"><span class=\"diagram-pill accent\">Actions</span><small class=\"diagram-muted\">default surface</small></div><div class=\"diagram-row\"><span class=\"diagram-pill\">/_agent-native/*</span><small class=\"diagram-muted\">framework routes</small></div><div class=\"diagram-row\"><span class=\"diagram-pill\">/api/*</span><small class=\"diagram-muted\">custom file routes</small></div><div class=\"diagram-row\"><span class=\"diagram-pill\">plugins</span><small class=\"diagram-muted\">startup: migrations, jobs</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough>SQL database<br><small class=\"diagram-muted\">Drizzle · the coordination point</small></div></div>",
+  "css": ".diagram-server{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-server .diagram-col{display:flex;flex-direction:column;gap:10px}.diagram-server .diagram-panel{display:flex;flex-direction:column;gap:8px;padding:14px 16px}.diagram-server .diagram-row{display:flex;align-items:center;gap:8px}.diagram-server .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+## फ़ाइल-आधारित रूट {#file-based-routes}
+
+मार्ग `server/routes/` में रहते हैं और Nitro फ़ाइल नामों को विधियों और पथों में मैप करते हैं:
+
+```text
+server/routes/
+  api/
+    health.get.ts              -> GET  /api/health
+    uploads.post.ts            -> POST /api/uploads
+    webhooks/
+      stripe.post.ts           -> POST /api/webhooks/stripe
+  [...page].get.ts             -> SSR catch-all for public pages
+```
+
+प्रत्येक मार्ग एक `defineEventHandler` निर्यात करता है:
+
+```ts
+// server/routes/api/health.get.ts
+import { defineEventHandler } from "h3";
+
+export default defineEventHandler(() => ({
+  ok: true,
+  service: "my-template",
+}));
+```
+
+### मार्ग नामकरण परंपराएँ {#route-naming-conventions}
+
+| फ़ाइल नाम पैटर्न   | HTTP विधि | उदाहरण पथ                |
+| ------------------ | --------- | ------------------------ |
+| `index.get.ts`     | GET       | `/api/items`             |
+| `index.post.ts`    | POST      | `/api/items`             |
+| `[id].get.ts`      | GET       | `/api/items/:id`         |
+| `[id].patch.ts`    | PATCH     | `/api/items/:id`         |
+| `[id].delete.ts`   | DELETE    | `/api/items/:id`         |
+| `[...slug].get.ts` | GET       | `/api/items/*` या कैच-ऑल |
+
+## ऐप संचालन के लिए Actions को प्राथमिकता दें {#actions-first}
+
+यदि UI और एजेंट दोनों को कुछ करने की आवश्यकता है, तो कस्टम API रूट के बजाय एक क्रिया को परिभाषित करें। Actions स्वचालित रूप से बन जाता है:
+
+- एजेंट टूल्स.
+- टाइप किए गए फ्रंटएंड हुक।
+- `/_agent-native/actions/:name` के अंतर्गत HTTP समापन बिंदु।
+- MCP और A2A-कॉल करने योग्य उपकरण।
+- CLI विकास के लिए आदेश।
+
+कस्टम `/api/*` रूट का उपयोग केवल तभी करें जब आपको रूट-आकार वाले प्रोटोकॉल या बाइनरी/स्ट्रीमिंग व्यवहार की आवश्यकता हो। [Actions](/docs/actions) देखें.
+
+## एक-शॉट पाठ समापन {#complete-text}
+
+अधिकांश AI कार्य एजेंट चैट के माध्यम से होना चाहिए ताकि उपयोगकर्ता देख सकें, संचालन कर सकें और ऑडिट कर सकें
+क्या हुआ. संकीर्ण सर्वर-साइड परिवर्तनों के लिए जिनकी जानबूझकर आवश्यकता नहीं है
+उपकरण, चैट इतिहास, या रन स्थिति, स्पष्ट एस्केप के रूप में `completeText()` का उपयोग करें
+हैच.
+
+```ts
+// actions/classify-message.ts
+import { defineAction } from "@agent-native/core/action";
+import { completeText } from "@agent-native/core/server";
+import { z } from "zod";
+
+export default defineAction({
+  description: "Classify a short message",
+  schema: z.object({ body: z.string() }),
+  run: async ({ body }) => {
+    const result = await completeText({
+      systemPrompt:
+        "Return exactly one label: urgent, follow-up, waiting, or archive.",
+      input: body,
+      maxOutputTokens: 16,
+      temperature: 0,
+    });
+
+    return { label: result.text.trim() };
+  },
+});
+```
+
+`completeText()` एजेंट के समान कॉन्फ़िगर इंजन परत के माध्यम से चलता है
+चैट, जिसमें Builder, एंथ्रोपिक, AI SDK प्रदाता, उपयोगकर्ता/ऐप मॉडल डिफ़ॉल्ट शामिल हैं,
+अनुरोध-दायरे वाले रहस्य, और इंजन-सामान्यीकृत त्रुटियाँ। यह केवल सर्वर है; मत करो
+क्लाइंट कोड से मॉडल प्रदाताओं को कॉल करें। यदि ऑपरेशन उपयोगकर्ता-सामना वाला है, तो इसे लपेटें
+एक कार्रवाई में इसलिए UI और एजेंट समान क्षमता साझा करते हैं।
+
+## संदर्भ और पहुंच का अनुरोध करें {#request-context}
+
+फ़्रेमवर्क द्वारा माउंट किया गया Actions स्वचालित रूप से अनुरोध संदर्भ के साथ चलता है। कस्टम मार्ग नहीं हैं. यदि कोई कस्टम रूट स्वामित्व योग्य संसाधनों को पढ़ता या लिखता है, तो सत्र लोड करें और कार्य को लपेटें:
+
+```an-annotated-code title="Scoping a custom route to the request user"
+{
+  "filename": "server/routes/api/projects.get.ts",
+  "language": "ts",
+  "code": "import { defineEventHandler, createError } from \"h3\";\nimport { getSession, runWithRequestContext } from \"@agent-native/core/server\";\nimport { getDb } from \"../../db/index.js\";\nimport { accessFilter } from \"@agent-native/core/sharing\";\nimport * as schema from \"../../db/schema\";\n\nexport default defineEventHandler(async (event) => {\n  const session = await getSession(event);\n  if (!session?.email) {\n    throw createError({ statusCode: 401, statusMessage: \"Unauthorized\" });\n  }\n\n  return runWithRequestContext(\n    { userEmail: session.email, orgId: session.orgId },\n    async () => {\n      const db = getDb();\n      return db\n        .select()\n        .from(schema.projects)\n        .where(accessFilter(schema.projects, schema.projectShares));\n    },\n  );\n});",
+  "annotations": [
+    { "lines": "7-10", "label": "Custom routes have no auto-context", "note": "Unlike actions, a file route must load the session itself and fail closed when there is no authenticated user." },
+    { "lines": "12-13", "label": "Establish request context", "note": "`runWithRequestContext` makes the user/org available to scoping helpers for the duration of the work." },
+    { "lines": "18-19", "label": "Scope ownable reads", "note": "`accessFilter` constrains the query to rows the caller may see. Never run an unscoped `db.select().from(ownableTable)` here." }
+  ]
+}
+```
+
+`server/db/index.ts` में `createGetDb(schema)` के माध्यम से प्रति ऐप `getDb` बनाया जाता है, इसलिए कस्टम रूट इसे टेम्पलेट (`../../db/index.js`) से आयात करते हैं, `@agent-native/core/db` से नहीं; [Database — Where the DB Client Lives](/docs/database#db-client) देखें। कस्टम मार्गों में बिना दायरे वाले `db.select().from(ownableTable)` को न चलाएं।
+
+## सर्वर प्लगइन्स {#server-plugins}
+
+प्लगइन्स `server/plugins/` में रहते हैं और स्टार्टअप पर चलते हैं। माइग्रेशन, प्रदाता सेटअप, आवर्ती नौकरियों, एकीकरण एडाप्टर और फ्रेमवर्क प्लगइन कॉन्फ़िगरेशन के लिए उनका उपयोग करें।
+
+```ts
+// server/plugins/db.ts
+import { runMigrations } from "@agent-native/core/db";
+
+export default runMigrations(
+  [
+    {
+      version: 1,
+      sql: `CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      owner_email TEXT NOT NULL,
+      org_id TEXT,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )`,
+    },
+  ],
+  { table: "my_app_migrations" },
+);
+```
+
+माइग्रेशन योगात्मक होना चाहिए। स्टार्टअप प्लगइन्स में कभी भी विनाशकारी SQL न डालें।
+
+## फ्रेमवर्क-माउंटेड रूट {#framework-routes}
+
+फ्रेमवर्क `/_agent-native/` के तहत अपने स्वयं के मार्गों को माउंट करता है। उस नामस्थान को आरक्षित मानें।
+
+| रूट उपसर्ग                       | उद्देश्य                                                                        |
+| -------------------------------- | ------------------------------------------------------------------------------- |
+| `/_agent-native/actions/:name`   | कार्रवाई HTTP समापन बिंदु                                                       |
+| `/_agent-native/agent-chat`      | एजेंट चैट लूप                                                                   |
+| `/_agent-native/poll`            | SQL-समर्थित UI सिंक                                                             |
+| `/_agent-native/resources/*`     | कार्यस्थान संसाधन                                                               |
+| `/_agent-native/extensions/*`    | रनटाइम एक्सटेंशन और एक्सटेंशन प्रॉक्सी (विरासत उपनाम: `/_agent-native/tools/*`) |
+| `/_agent-native/integrations/*`  | मैसेजिंग/वेबहुक एकीकरण                                                          |
+| `/_agent-native/a2a`             | एजेंट-से-एजेंट JSON-RPC                                                         |
+| `/_agent-native/mcp`             | MCP समापन बिंदु                                                                 |
+| `/_agent-native/onboarding/*`    | सेटअप चेकलिस्ट                                                                  |
+| `/_agent-native/observability/*` | निशान, फीडबैक, मूल्यांकन, प्रयोग                                                |
+| `/_agent-native/file-upload`     | फ़ाइल अपलोड प्रदाता समापन बिंदु                                                 |
+
+कस्टम ऐप रूट को `/api/*`, सार्वजनिक ऐप पथ, या प्रदाता-विशिष्ट कॉलबैक पथ का उपयोग करना चाहिए जो `/_agent-native/` से नहीं टकराते।
+
+## SQL-समर्थित सिंक {#sync}
+
+एजेंट-नेटिव फ़ाइल सिस्टम पर नजर रखने वालों या स्टिकी इन-मेमोरी स्थिति पर भरोसा नहीं करता है। जब actions या फ्रेमवर्क सहायक डेटा को बदलते हैं, तो डेटाबेस सिंक संस्करण बढ़ता है। क्लाइंट `useDbSync()` हुक पोल `/_agent-native/poll` करता है और React क्वेरी कैश को अमान्य कर देता है।
+
+यह सर्वर रहित और मल्टी-इंस्टेंस परिनियोजन पर काम करता है क्योंकि डेटाबेस समन्वय बिंदु है। यदि आप actions के बाहर कस्टम म्यूटेशन लिखते हैं, तो फ्रेमवर्क हेल्पर्स का उपयोग करें या उचित सिंक अमान्यकरण का उत्सर्जन करें, इसलिए UIs रिफ्रेश खोलें।
+
+```an-diagram title="SQL-backed sync loop" summary="No watchers, no sticky state. A write bumps a version in SQL; every client polls the version and refetches."
+{
+  "html": "<div class=\"diagram-sync\"><div class=\"diagram-box\" data-rough>Action / helper<br><small class=\"diagram-muted\">mutates data</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel\" data-rough><strong>SQL database</strong><small class=\"diagram-muted\">sync version increments</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&larr;</div><div class=\"diagram-col\"><div class=\"diagram-node\">useDbSync()<br><small class=\"diagram-muted\">polls /_agent-native/poll</small></div><div class=\"diagram-pill ok\">invalidate caches &rarr; UI refreshes</div></div></div>",
+  "css": ".diagram-sync{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-sync .diagram-col{display:flex;flex-direction:column;gap:8px;align-items:flex-start}.diagram-sync .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+```an-api title="The poll endpoint" method="GET" path="/_agent-native/poll"
+{
+  "method": "GET",
+  "path": "/_agent-native/poll",
+  "summary": "Return the current per-source database sync versions so the client can detect changes.",
+  "description": "`useDbSync()` calls this on an interval (and falls back to it when SSE is unavailable). When a returned version is higher than the client's last-seen value, the matching React Query caches are invalidated and refetch.",
+  "auth": "Session cookie (request-scoped identity)",
+  "responses": [
+    { "status": "200", "description": "Current sync versions keyed by source." }
+  ]
+}
+```
+
+## Webhooks {#webhooks}
+
+इनबाउंड webhooks को सत्यापित करना चाहिए, जारी रखना चाहिए और जल्दी वापस लौटना चाहिए। लंबे समय तक चलने वाले एजेंट कार्य को एकीकरण कतार पैटर्न का उपयोग करना चाहिए:
+
+1. प्लेटफ़ॉर्म हस्ताक्षर या चुनौती को सत्यापित करें।
+2. SQL में टिकाऊ कार्य डालें।
+3. हस्ताक्षरित प्रोसेसर रूट को स्वयं सक्रिय करें।
+4. तुरंत 200 वापस करें।
+5. ताजा प्रोसेसर निष्पादन को एजेंट लूप चलाने दें और परिणाम पोस्ट करें।
+
+```an-diagram title="Integration queue pattern" summary="The webhook handler returns in milliseconds; a separate signed execution runs the slow agent work."
+{
+  "html": "<div class=\"diagram-webhook\"><div class=\"diagram-box\" data-rough>Inbound webhook<br><small class=\"diagram-muted\">Slack · Stripe · email</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel\" data-rough><strong>Handler</strong><div class=\"diagram-step\"><span class=\"diagram-pill\">1</span><small class=\"diagram-muted\">verify signature</small></div><div class=\"diagram-step\"><span class=\"diagram-pill\">2</span><small class=\"diagram-muted\">insert work into SQL</small></div><div class=\"diagram-step\"><span class=\"diagram-pill\">3</span><small class=\"diagram-muted\">self-fire processor</small></div><div class=\"diagram-step\"><span class=\"diagram-pill ok\">4</span><small class=\"diagram-muted\">return 200 now</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough>Signed processor<br><small class=\"diagram-muted\">runs agent loop, posts result</small></div></div>",
+  "css": ".diagram-webhook{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-webhook .diagram-panel{display:flex;flex-direction:column;gap:6px;padding:14px 16px}.diagram-webhook .diagram-step{display:flex;align-items:center;gap:8px}.diagram-webhook .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+> [!WARNING]
+> प्रतिक्रिया देने के बाद अप्रतीक्षित वादों पर भरोसा न करें - सर्वर रहित होस्ट निष्पादन को रोक देते हैं। विहित एकीकरण कतार के लिए [Messaging](/docs/messaging) देखें।
+
+## उन्नत: एस्केप हैच {#advanced-escape-hatches}
+
+अधिकांश टेम्प्लेट को कभी भी इनकी आवश्यकता नहीं होती है। Nitro फ़ाइल रूट और फ़्रेमवर्क का एजेंट
+चैट प्लगइन पहले से ही ऐप सर्वर और प्रोडक्शन एजेंट हैंडलर को वायर अप कर देता है।
+केवल तभी उन तक पहुंचें जब आप
+मानक टेम्पलेट प्लगइन स्टैक।
+
+### प्रोग्रामेटिक H3 सर्वर {#create-server}
+
+कस्टम पैकेज या परीक्षणों के लिए जिन्हें सीधे H3 ऐप की आवश्यकता होती है, `createServer()`
+एक पूर्व-कॉन्फ़िगर किया गया ऐप और राउटर लौटाता है:
+
+```ts
+import { createServer } from "@agent-native/core/server";
+import { defineEventHandler } from "h3";
+
+const { app, router } = createServer();
+
+router.get(
+  "/api/health",
+  defineEventHandler(() => ({ ok: true })),
+);
+```
+
+### प्रोडक्शन एजेंट हैंडलर {#agent-handler}
+
+फ्रेमवर्क का एजेंट चैट प्लगइन पहले से ही प्रोडक्शन एजेंट हैंडलर को माउंट करता है
+टेम्प्लेट के लिए। निर्माण करते समय केवल `createProductionAgentHandler()` पर सीधे कॉल करें
+मानक टेम्पलेट प्लगइन स्टैक के बाहर एक कस्टम सर्वर एकीकरण -
+अन्यथा एजेंट को `AGENTS.md`, skills, actions, और के माध्यम से अनुकूलित करें
+एजेंट चैट प्लगइन.
+
+```ts
+import { createProductionAgentHandler } from "@agent-native/core/server";
+
+const handler = createProductionAgentHandler({
+  scripts,
+  systemPrompt: "You are the app agent...",
+});
+```