@agent-native/core 0.76.5 → 0.76.6

package/docs/content/locales/hi-IN/human-approval.md

@@ -0,0 +1,86 @@
+---
+title: "मानव-इन-द-लूप स्वीकृतियां"
+description: "उच्च-परिणाम वाली कार्रवाई चलने से पहले एजेंट को रोकें - defineAction की आवश्यकताएं अनुमोदन गेट एक अनुमोदन_आवश्यक घटना उत्सर्जित करता है, मानव अनुमोदन करता है, और उसके बाद ही उपकरण निष्पादित होता है।"
+---
+
+# मानव-इन-द-लूप स्वीकृतियाँ
+
+अधिकांश actions को बस चलना चाहिए। कुछ - एक ईमेल भेजना, एक कार्ड चार्ज करना, एक खाता हटाना - बाहर की ओर हैं और पूर्ववत करना कठिन है, और आप नहीं चाहते कि एजेंट उन्हें स्वायत्त रूप से करे। उन लोगों के लिए, `defineAction` में एक ऑप्ट-इन **अनुमोदन गेट** है: जब एजेंट कार्रवाई को कॉल करने का प्रयास करता है, तो लूप रुक जाता है, मानव के सामने अनुमोदन/अस्वीकार करने का प्रस्ताव सामने आता है, और मानव द्वारा उस विशिष्ट कॉल को मंजूरी देने के बाद ही कार्रवाई शुरू होती है।
+
+> [!WARNING]
+> स्वीकृतियां दुर्लभ रखें। प्रत्येक गेटेड कार्रवाई एजेंट लूप में एक कठिन पड़ाव है - यह रन को बाधित करती है और मानव राउंड-ट्रिप की मांग करती है। `needsApproval` का उपयोग केवल वास्तव में उच्च-परिणाम, कठिन-से-पूर्ववत, बाहरी-सामना वाले संचालन के लिए करें। यदि आप स्वयं को नियमित रूप से पढ़ने या लिखने में व्यस्त पाते हैं, तो आप इसे गलत मान रहे हैं। डिफ़ॉल्ट **बंद** है, और लगभग हर क्रिया को इसे बंद छोड़ देना चाहिए।
+
+## `needsApproval` गेट {#needs-approval}
+
+`needsApproval` को `defineAction` पर सेट करें। यह एक बूलियन या विधेय को स्वीकार करता है:
+
+```an-annotated-code title="Gating the one consequential action"
+{
+  "filename": "actions/send-email.ts",
+  "language": "ts",
+  "code": "export default defineAction({\n  description: \"Send an email via Gmail.\",\n  schema: z.object({\n    to: z.string(),\n    subject: z.string(),\n    body: z.string(),\n  }),\n  // Sending is outward-facing and hard to undo, so the agent can never send\n  // without a human approving the specific call. Drafting/queueing is\n  // unaffected — only the real send is gated.\n  needsApproval: true,\n  run: async (args) => {\n    /* ...actually send... */\n  },\n});",
+  "annotations": [
+    { "lines": "10", "label": "The whole gate", "note": "One flag. With it truthy and the call unapproved, the loop stops before `run` — the model never reaches the side effect on its own." },
+    { "lines": "11-13", "label": "run() is untouched", "note": "The handler stays the same. Approval is enforced by the loop around it, not by anything inside `run`." }
+  ]
+}
+```
+
+- **`needsApproval: true`** - हमेशा अनुमोदन की आवश्यकता होती है।
+- **`needsApproval: (args, ctx) => boolean | Promise<boolean>`** - केवल तभी अनुमोदन की आवश्यकता होती है जब विधेय सत्य हो। गेट सशर्त, उदा. केवल बाहरी प्राप्तकर्ताओं के लिए या केवल एक डॉलर सीमा से ऊपर के लिए:
+
+  ```ts
+  अनुमोदन की आवश्यकता: (args) => !args.to.endsWith("@your-company.com"),
+  ```
+
+  विधेय को शुद्ध और तेज़ रखें। **यह बंद होने में विफल रहता है**: यदि विधेय फेंकता है, तो रूपरेखा उच्च-परिणाम वाली कार्रवाई को चुपचाप चलाने के बजाय इसे "अनुमोदन आवश्यक" मानती है।
+
+जब `needsApproval` को हटा दिया जाता है, तो व्यवहार बाइट-दर-बाइट अपरिवर्तित होता है - सामान्य पथ पर कोई अतिरिक्त लागत नहीं होती है।
+
+यह लीगेसी `parameters`-शैली actions और स्कीमा-आधारित actions, और इन-ऐप एजेंट, उप-एजेंट, A2A और MCP कॉलर्स (प्रत्येक एजेंट एक ही लूप के माध्यम से रूट करता है) के लिए समान काम करता है।
+
+## लूप कैसे रुकता है {#loop}
+
+जब एजेंट एक गेटेड एक्शन कॉल करता है और यह विशिष्ट कॉल पहले से ही स्वीकृत **नहीं** है, तो लूप `run()` निष्पादित **नहीं** करता है। इसके बजाय:
+
+1. गेट का समाधान करता है। विधेय के लिए, यह `needsApproval(input, ctx)` कहता है; एक थ्रो को "मस्ट अप्रूवल" (असफल बंद) माना जाता है।
+2. एक `tool_start` ईवेंट उत्सर्जित करता है (इसलिए UI कॉल दिखाता है) जिसके तुरंत बाद एक **`approval_required`** ईवेंट होता है, फिर टर्न बंद हो जाता है। क्रिया का दुष्प्रभाव कभी नहीं होता.
+
+`approval_required` इवेंट में वह सब कुछ उपलब्ध है जो ग्राहक को खर्च वहन करने के लिए चाहिए:
+
+| फ़ील्ड        | प्रकार   | नोट्स                                                                                 |
+| ------------- | -------- | ------------------------------------------------------------------------------------- |
+| `tool`        | `string` | एजेंट ने जिस क्रिया नाम पर कॉल करने का प्रयास किया।                                   |
+| `input`       | वस्तु    | एजेंट द्वारा पारित तर्क।                                                              |
+| `approvalKey` | `string` | **स्थिर कुंजी** क्लाइंट _इस सटीक कॉल_ को स्वीकृत करने के लिए वापस प्रतिध्वनि करता है। |
+| `toolCallId`  | `string` | मॉडल-साइड टूल-कॉल आईडी, जब उपलब्ध हो।                                                 |
+
+`approvalKey` निश्चित रूप से टूल नाम और उसके इनपुट से प्राप्त होता है, इसलिए एक ही तार्किक कॉल हमेशा एक ही कुंजी उत्पन्न करती है। मॉडल इसे कभी नहीं देखता या सेट नहीं करता - यह पूरी तरह से ढांचे और मानव की स्वीकृत क्षमता के बीच एक हाथ मिलाना है।
+
+रोका गया टूल मॉडल को यह बताते हुए एक परिणाम देता है कि टर्न रुका हुआ है और पुनः प्रयास नहीं करना है, इसलिए मॉडल घूमता नहीं है।
+
+## मनुष्य कैसे अनुमोदन करता है {#approve}
+
+`approval_required` पर, चैट UI रुके हुए टूल कॉल पर **अनुमोदन/अस्वीकार** का लाभ प्रदान करता है। यह `AssistantChat` में स्वचालित रूप से वायर्ड है - आप इसे प्रति टेम्पलेट के अनुसार नहीं बनाते हैं।
+
+- **अनुमोदन** `approvedToolCalls: [approvalKey]` में कॉल की कुंजी ले जाने वाले टर्न (एक सामान्य निरंतरता संदेश) को फिर से जारी करता है। पुनः जारी किए गए टर्न पर, गेट स्वीकृत सेट में कुंजी देखता है और उस विशिष्ट कॉल को सामान्य रूप से चलने देता है।
+- **इनकार** स्थानीय स्तर पर खर्च को खारिज करता है; कुछ भी पुनः जारी नहीं किया जाता है, इसलिए कार्रवाई कभी नहीं चलती है।
+
+`approvedToolCalls` चैट अनुरोध (`AgentChatRequest.approvedToolCalls`) पर एक फ़ील्ड है। इसमें मौजूद नहीं होने वाली कुंजियाँ रुकी रहती हैं - एक कॉल को स्वीकृत करना कभी भी अन्य को रिक्त रूप से स्वीकृत नहीं करता है। क्योंकि कुंजी सामग्री-संबोधित है, एक अनुमोदन _उस कॉल को उन तर्कों के साथ अधिकृत करता है_; यदि मॉडल बाद में एक अलग भेजने का प्रस्ताव करता है, तो यह एक नई कुंजी और एक नई स्वीकृति है।
+
+## एंड-टू-एंड {#flow}
+
+```an-diagram title="The approval interrupt" summary="A gated call pauses the turn before run() fires. Approval re-issues the turn carrying the call's key; only then does the side effect happen."
+{
+  "html": "<div class=\"diagram-approve\"><div class=\"diagram-box\" data-rough>Agent calls send-email</div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-panel warn\" data-rough><strong>Gate truthy, call not yet approved</strong><small class=\"diagram-muted\">loop emits tool_start + approval_required { tool, input, approvalKey }</small><span class=\"diagram-pill warn\">turn pauses &mdash; run() did NOT execute</span></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-box\" data-rough>Human clicks Approve in chat<br><small class=\"diagram-muted\">client re-issues the turn with approvedToolCalls: [approvalKey]</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-panel ok\" data-rough><span class=\"diagram-pill ok\">Gate sees the key &rarr; run() executes &rarr; email sends</span></div></div>",
+  "css": ".diagram-approve{display:flex;flex-direction:column;align-items:center;gap:8px}.diagram-approve .diagram-panel{display:flex;flex-direction:column;gap:6px;align-items:center;padding:12px 16px;text-align:center}.diagram-approve .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+फ्रेमवर्क में इस गेट का विहित (और जानबूझकर दुर्लभ) उपयोग मेल टेम्पलेट की `send-email` कार्रवाई है, जो `needsApproval: true` सेट करता है ताकि एजेंट स्वतंत्र रूप से ड्राफ्ट और कतारबद्ध हो सके लेकिन वास्तव में किसी मानव द्वारा विशिष्ट प्रेषण को मंजूरी दिए बिना कभी भी संदेश नहीं भेज सकता है।
+
+## संबंधित
+
+- [**Actions**](/docs/actions#needs-approval) - पूर्ण `defineAction` सतह, जिसमें रिटर्न मानों को मान्य करने के लिए `outputSchema` भी शामिल है।
+- [**Security**](/docs/security) - अनुमोदन गेट तक कब पहुंचना है बनाम किसी कार्रवाई को मॉडल से छिपाना है।
+- [**Mail template**](/docs/template-mail) - `send-email` संदर्भ उदाहरण है।

package/docs/content/locales/hi-IN/internationalization.md

@@ -1,15 +1,18 @@
 ---
-title: "अंतरराष्ट्रीयकरण"
-description: "shared locale catalogs, language picker, browser-language fallback और locale-aware docs content के साथ Agent Native apps को localize करें।"
+title: "अंतर्राष्ट्रीयकरण"
+description: "साझा स्थानीय कैटलॉग, एक भाषा पिकर, ब्राउज़र-भाषा फ़ॉलबैक और स्थानीय-जागरूक डॉक्स सामग्री के साथ Agent Native ऐप्स को स्थानीयकृत करें।"
 ---
 
-# अंतरराष्ट्रीयकरण
+# अंतर्राष्ट्रीयकरण
 
-Agent Native apps shared `@agent-native/core/client/i18n` runtime के जरिए framework और template UI को localize कर सकते हैं। framework उपयोगकर्ता की भाषा पसंद को SQL settings में store करता है, उसे actions के रूप में expose करता है, और जब किसी app में कोई string translate नहीं होती तो English पर fallback करता है।
+Agent Native ऐप्स साझा के माध्यम से फ्रेमवर्क और टेम्पलेट UI को स्थानीयकृत कर सकते हैं
+`@agent-native/core/client/i18n` रनटाइम। फ़्रेमवर्क उपयोगकर्ता को संग्रहीत करता है
+SQL सेटिंग्स में भाषा का चयन, इसे actions के रूप में प्रदर्शित करता है, और वापस आ जाता है
+अंग्रेजी जब किसी ऐप ने अभी तक किसी स्ट्रिंग का अनुवाद नहीं किया है।
 
-## Runtime {#runtime}
+## रनटाइम
 
-Provider को `AppProviders` के जरिए इस्तेमाल करें:
+`AppProviders` के माध्यम से प्रदाता का उपयोग करें:
 
 ```tsx
 import { AppProviders, getLocaleInitScript } from "@agent-native/core/client";
@@ -27,11 +30,14 @@ const LOCALE_INIT_SCRIPT = getLocaleInitScript();
 </AppProviders>;
 ```
 
-`getLocaleInitScript()` React hydration से पहले शुरुआती `lang`, `dir`, और `window.__AGENT_NATIVE_LOCALE__` सेट करता है। Public SSR routes `@agent-native/core/server` से `resolveLocaleFromRequest()` call कर सकते हैं और resolved locale/catalog को script में pass कर सकते हैं ताकि hydration mismatch न हो।
+`getLocaleInitScript()` प्रारंभिक `lang`, `dir`, और
+React हाइड्रेट होने से पहले `window.__AGENT_NATIVE_LOCALE__`। सार्वजनिक SSR मार्ग
+`@agent-native/core/server` से `resolveLocaleFromRequest()` को कॉल करें और पास करें
+हाइड्रेशन बेमेल से बचने के लिए उस स्क्रिप्ट में लोकेल/कैटलॉग को हल किया गया।
 
-## Catalogs {#catalogs}
+## कैटलॉग
 
-हर localized template catalogs को `app/i18n/` में रखता है:
+प्रत्येक स्थानीयकृत टेम्पलेट कैटलॉग को `app/i18n/` के अंतर्गत रखता है:
 
 ```ts
 // app/i18n/index.ts
@@ -52,51 +58,88 @@ export const i18nCatalog = {
 } satisfies AgentNativeI18nCatalog;
 ```
 
-हमेशा `en-US` bundle करें। Non-English catalogs को dynamic import करें ताकि users केवल active locale download करें। Supported locale codes हैं `en-US`, `zh-CN`, `es-ES`, `fr-FR`, `de-DE`, `ja-JP`, `ko-KR`, `pt-BR`, `hi-IN`, और `ar-SA`।
+हमेशा `en-US` को बंडल करें। डायनामिक-आयात गैर-अंग्रेज़ी कैटलॉग केवल उपयोगकर्ताओं के लिए
+सक्रिय लोकेल डाउनलोड करें। समर्थित स्थानीय कोड `en-US`, `zh-CN`,
+`es-ES`, `fr-FR`, `de-DE`, `ja-JP`, `ko-KR`, `pt-BR`, `hi-IN`, और `ar-SA`।
 
-## UI {#ui}
+## UI
 
-Interface strings के लिए `useT()` और settings में `<LanguagePicker />` इस्तेमाल करें:
+इंटरफ़ेस स्ट्रिंग्स के लिए `useT()` का उपयोग करें और ऐप पर `<LanguagePicker />` डालें
+`/settings` पेज। साइडबार ऐप्स को ऐप साइडबार में **सेटिंग्स** को प्रदर्शित करना चाहिए;
+हेडर भाषा आइकन केवल एक शॉर्टकट है।
 
 ```tsx
-import { LanguagePicker, useT } from "@agent-native/core/client";
+import {
+  LanguagePicker,
+  openAgentSettings,
+  useT,
+} from "@agent-native/core/client";
 
-function SettingsLanguageCard() {
+function SettingsPage() {
   const t = useT();
   return (
     <>
       <h2>{t("settings.languageTitle")}</h2>
       <LanguagePicker label={t("settings.languageLabel")} />
+
+      <h2>{t("settings.agentTitle")}</h2>
+      <p>{t("settings.agentDescription")}</p>
+      <button type="button" onClick={() => openAgentSettings()}>
+        {t("settings.openAgentSettings")}
+      </button>
     </>
   );
 }
 ```
 
-Dates, numbers, relative time और lists के लिए `useFormatters()` इस्तेमाल करें। Locale-sensitive date/number formatting को translation strings में embed न करें।
+"एजेंट सेटिंग" नियंत्रण को सही एजेंट साइडबार का सेटिंग टैब खोलना चाहिए
+मॉडल, API कुंजी, स्वचालन, आवाज और अन्य फ्रेमवर्क-स्तरीय नियंत्रणों के लिए।
+ऐप्स अपने स्वयं के सेटिंग पेज में उच्च-मूल्य फ़्रेमवर्क सेटिंग्स की नकल कर सकते हैं
+जब सेटिंग ऐप के केंद्र में होती है, लेकिन साइडबार सेटिंग टैब
+सत्य का स्रोत।
+
+तिथि, संख्या, सापेक्ष समय और सूचियों के लिए `useFormatters()` का उपयोग करें। मत डालो
+अनुवाद स्ट्रिंग के अंदर स्थान-संवेदनशील दिनांक/संख्या स्वरूपण।
 
-## Docs site content {#docs-site-content}
+## दस्तावेज़ साइट सामग्री {#docs-site-content}
 
-Public docs pages वही core provider इस्तेमाल करते हैं, लेकिन `persistPreference={false}` के साथ, ताकि anonymous docs traffic SQL settings actions की जगह localStorage और browser language इस्तेमाल करे। English source `packages/core/docs/content/*.md` में रहता है। Localized page overrides `packages/core/docs/content/locales/<locale>/<slug>.md` में रहते हैं।
+सार्वजनिक दस्तावेज़ पृष्ठ समान मूल प्रदाता का उपयोग करते हैं, लेकिन
+`persistPreference={false}` इसलिए अनाम दस्तावेज़ ट्रैफ़िक लोकलस्टोरेज और का उपयोग करता है
+SQL सेटिंग्स actions के बजाय ब्राउज़र भाषा। अंग्रेजी स्रोत
+`packages/core/docs/content/*.md`. स्थानीयकृत पृष्ठ
+`packages/core/docs/content/locales/<locale>/<slug>.md`.
 
-App catalogs जैसे ही BCP-47 locale codes इस्तेमाल करें। English source जैसा slug रखें, translated headings पर `{#anchor}` से stable anchors preserve करें, और routes, action names, protocol fields, env vars या provider names translate न करें। अगर किसी locale में किसी page का translated Markdown नहीं है, docs site उस page के लिए English fallback करेगा और navigation/chrome फिर भी localize रहेगा।
+ऐप कैटलॉग के रूप में समान BCP-47 लोकेल कोड का उपयोग करें। स्लग को
+अंग्रेजी स्रोत, अनुवादित शीर्षकों पर `{#anchor}` के साथ स्थिर एंकर सुरक्षित रखें,
+और मार्ग, क्रिया नाम, प्रोटोकॉल फ़ील्ड, एनवी संस्करण और प्रदाता नाम छोड़ दें
+अअनुवादित. यदि किसी लोकेल में किसी पेज के लिए कोई अनुवादित Markdown नहीं है, तो डॉक्स साइट
+नेविगेशन और क्रोम को स्थानीयकृत करते समय उस पृष्ठ के लिए अंग्रेजी में वापस आ जाता है।
 
-## Actions और persistence {#actions-and-persistence}
+## Actions और दृढ़ता
 
-हर app को मिलता है:
+प्रत्येक ऐप को ये विरासत मिलती है:
 
-- `get-localization-preference` — current user का `{ locale }` पढ़ता है
-- `set-localization-preference` — `"system"` या supported locale सेट करता है
+- `get-localization-preference` — वर्तमान उपयोगकर्ता का `{ locale }` पढ़ें
+- `set-localization-preference` - `"system"` या एक समर्थित लोकेल सेट करें
 
-Durable value user-scoped SQL settings में `localization` key के तहत रहता है। `localStorage` केवल pre-hydration और anonymous fallback के लिए है। Active locale application state में ambient context के रूप में mirror होता है ताकि agents current interface language देख सकें।
+टिकाऊ मान `localization` के अंतर्गत उपयोगकर्ता-स्कोप वाली SQL सेटिंग्स में रहता है।
+`localStorage` का उपयोग केवल प्री-हाइड्रेशन और अनाम फ़ॉलबैक के लिए किया जाता है। सक्रिय
+लोकेल को परिवेशीय संदर्भ के रूप में एप्लिकेशन स्थिति में प्रतिबिंबित किया जाता है ताकि एजेंट देख सकें
+वर्तमान इंटरफ़ेस भाषा।
 
-## Guard {#guard}
+## रक्षक
 
-चलाएं:
+चलाएँ:
 
 ```bash
 pnpm guard:i18n-catalogs
 ```
 
-Guard supported locale filenames, key parity, placeholder parity, stale keys, और `Intl.PluralRules` के जरिए CLDR plural categories verify करता है। यह structure check करता है, translation quality नहीं; high-visibility strings को human review चाहिए।
+गार्ड समर्थित स्थानीय फ़ाइल नाम, कुंजी समता, प्लेसहोल्डर समता, का सत्यापन करता है
+बासी कुंजियाँ, और `Intl.PluralRules` के माध्यम से CLDR बहुवचन श्रेणियाँ। यह जाँच करता है
+संरचना, अनुवाद गुणवत्ता नहीं; उच्च-दृश्यता वाले तारों को अभी भी मानव की आवश्यकता है
+समीक्षा.
 
-Stable identifiers जैसे action names, routes, enum values, app-state keys, database values, protocol fields, env var names या provider names translate न करें।
+कार्य नाम, मार्ग, एनम मान जैसे स्थिर पहचानकर्ताओं का अनुवाद न करें
+ऐप-स्टेट कुंजी, डेटाबेस मान, प्रोटोकॉल फ़ील्ड, env var नाम, या प्रदाता
+नाम.

package/docs/content/locales/hi-IN/key-concepts.md

@@ -0,0 +1,312 @@
+---
+title: "मुख्य अवधारणाएँ"
+description: "एजेंट-नेटिव ऐप्स कैसे काम करते हैं: actions पहले, SQL डेटाबेस, ऐप-एजेंट लूप, वैकल्पिक UI, पोलिंग सिंक, बाहरी-एजेंट प्रवेश बिंदु, संदर्भ जागरूकता और पोर्टेबिलिटी।"
+---
+
+# मुख्य अवधारणाएँ
+
+एजेंट-नेटिव ऐप्स हुड के तहत कैसे काम करते हैं - सिद्धांत और वास्तुकला। यह पृष्ठ अनुबंध है; इस तरह से निर्माण की दृष्टि और मामले के लिए, [What Is Agent-Native?](/docs/what-is-agent-native) देखें।
+
+## वास्तुकला {#the-architecture}
+
+प्रत्येक एजेंट-नेटिव ऐप तीन चीजें एक साथ काम करती हैं:
+
+> **एजेंट** - स्वायत्त एआई जो डेटा पढ़ता है, डेटा लिखता है, actions चलाता है, और कोड को संशोधित करता है। skills और निर्देशों के साथ अनुकूलन योग्य।
+>
+> **अनुप्रयोग** - एजेंट के चारों ओर उत्पाद की सतह। यह पहली बार में केवल एक्शन, रिच चैट, एक छोटा नियंत्रण विमान, या डैशबोर्ड, प्रवाह और विज़ुअलाइज़ेशन के साथ एक पूर्ण React UI हो सकता है।
+>
+> **कंप्यूटर** — डेटाबेस, ब्राउज़र, कोड निष्पादन। एजेंट सीधे SQL और अंतर्निर्मित टूल के साथ काम करते हैं; MCP सर्वर वैकल्पिक ऐड-ऑन हैं, फाउंडेशन नहीं।
+
+```an-diagram title="Agent, application, and computer" summary="Three layers working together over one shared SQL store. The agent and the application both read and write the same data."
+{
+  "html": "<div class=\"diagram-arch\"><div class=\"diagram-row\"><div class=\"diagram-card\"><span class=\"diagram-pill accent\">Agent</span><small class=\"diagram-muted\">reads + writes data, runs actions, modifies code</small></div><div class=\"diagram-card\"><span class=\"diagram-pill\">Application</span><small class=\"diagram-muted\">action-only, chat, control plane, or full React UI</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;&nbsp;&uarr;</div><div class=\"diagram-box\" data-rough>Computer<br><small class=\"diagram-muted\">SQL database · browser · code execution</small></div></div>",
+  "css": ".diagram-arch{display:flex;flex-direction:column;align-items:center;gap:10px}.diagram-arch .diagram-row{display:flex;gap:12px;flex-wrap:wrap;justify-content:center}.diagram-arch .diagram-card{display:flex;flex-direction:column;gap:6px;padding:14px 16px;min-width:220px}.diagram-arch .diagram-arrow{font-size:20px;line-height:1}.diagram-arch .diagram-box{text-align:center;padding:12px 18px}"
+}
+```
+
+हेडलेस ऐप्स `pnpm agent` वाले फ़ोल्डर से समान प्रोडक्शन ऐप-एजेंट लूप चला सकते हैं, जबकि UI ऐप्स एम्बेडेड एजेंट पैनल को माउंट करते हैं और `pnpm dev` के साथ स्थानीय रूप से चला सकते हैं। क्लाउड में, Builder.io एक प्रबंधित फ्रेम प्रदान करता है - वह वातावरण जो आपके ऐप के बगल में एजेंट को होस्ट करता है - टीमों के लिए सहयोग, दृश्य संपादन और प्रबंधित बुनियादी ढांचे के साथ।
+
+## एजेंट बिल्डिंग ब्लॉक्स {#agent-building-blocks}
+
+प्रत्येक एजेंट-नेटिव ऐप में समान एजेंट बिल्डिंग ब्लॉक होते हैं, चाहे कुछ भी हो
+उत्पाद की सतह हेडलेस, चैट-फर्स्ट या पूर्ण UI है:
+
+```an-file-tree title="Guidance and behavior"
+{
+  "entries": [
+    { "path": "AGENTS.md", "note": "always-on instructions: purpose, core rules, state keys, action index, skills index" },
+    { "path": ".agents/skills/<name>/SKILL.md", "note": "reusable behavior: workflow steps, policies, examples, references, and do/don't lists" },
+    { "path": "actions/<name>.ts", "note": "executable capability: typed operation exposed to the agent, UI, CLI, HTTP, MCP, A2A, jobs, and webhooks" }
+  ]
+}
+```
+
+| बिल्डिंग ब्लॉक | इसके लिए इसका उपयोग करें                                                                                                      | जब लोड किया गया                                                             |
+| -------------- | ----------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| **निर्देश**    | एजेंट को प्रत्येक कार्य में स्थिर मार्गदर्शन देना चाहिए: ऐप क्या है, इनवेरिएंट, टोन, इंडेक्स                                  | हर मोड़                                                                     |
+| **Skills**     | पुन: प्रयोज्य व्यवहार: वर्कफ़्लो का पालन कैसे करें, नीति कैसे लागू करें, साक्ष्य का निरीक्षण करें, या आउटपुट को सत्यापित करें | मांग पर जब कौशल विवरण कार्य से मेल खाता हो                                  |
+| **Actions**    | वास्तविक संचालन: डेटा पढ़ें या लिखें, APIs पर कॉल करें, संदेश भेजें, अनुमोदन चलाएं, टाइप किए गए परिणाम उत्पन्न करें           | हर मोड़ पर उपकरण के रूप में सूचीबद्ध; कॉल करने पर ही निष्पादित किया जाता है |
+
+Skills और actions एक साथ काम करते हैं। एक कौशल एजेंट को यह सिखाता है कि क्लास कैसे करनी है
+कार्य; एक क्रिया वह कोड पथ है जिसे वह उस कार्य को करते समय कॉल कर सकता है। उदाहरण के लिए,
+एक `customer-research` कौशल एजेंट को बता सकता है कि किन स्रोतों का निरीक्षण करना है और
+साक्ष्य को सारांशित कैसे करें, जबकि `search-crm` और `create-brief` actions प्राप्त करें
+और वास्तविक डेटा लिखें।
+
+छह नियम वास्तुकला को नियंत्रित करते हैं:
+
+1. **डेटा SQL में रहता है** - सभी ऐप स्थिति Drizzle ORM के माध्यम से डेटाबेस में रहती है
+2. **सभी एआई एजेंट के माध्यम से जाते हैं** - कोई इनलाइन LLM कॉल नहीं
+3. **एजेंट संचालन के लिए Actions** — जटिल कार्य actions के रूप में चलता है
+4. **लाइव सिंक UI को सिंक में रखता है** - सार्वभौमिक फ़ॉलबैक के रूप में पोलिंग के साथ डेटाबेस SSE पर स्ट्रीम बदलता है
+5. **एजेंट कोड को संशोधित कर सकता है** - जैसे-जैसे आप इसका उपयोग करते हैं, ऐप विकसित होता जाता है
+6. **SQL में एप्लिकेशन स्थिति** - अल्पकालिक UI स्थिति डेटाबेस में रहती है, जो एजेंट और UI दोनों द्वारा पढ़ने योग्य है
+
+## चार-क्षेत्रीय चेकलिस्ट {#four-area-checklist}
+
+प्रत्येक उपयोगकर्ता-सामना वाली सुविधा को सभी लागू क्षेत्रों को अद्यतन करना चाहिए। किसी लागू क्षेत्र को छोड़ने से एजेंट-मूल अनुबंध टूट जाता है; एक UI को केवल क्रिया-प्रधान प्रिमिटिव पर थोपना भी एक गंध है।
+
+| क्षेत्र         | विवरण                                                                   |
+| --------------- | ----------------------------------------------------------------------- |
+| **1. UI**       | पृष्ठ, घटक, या संवाद जिसके साथ उपयोगकर्ता इंटरैक्ट करता है              |
+| **2. कार्रवाई** | उसी ऑपरेशन के लिए actions/ में एजेंट-कॉल करने योग्य कार्रवाई            |
+| **3. Skills**   | AGENTS.md को अपडेट करें और/या पैटर्न का दस्तावेजीकरण करने का कौशल बनाएं |
+| **4. ऐप-स्टेट** | नेविगेशन स्थिति, व्यू-स्क्रीन डेटा, और नेविगेट कमांड                    |
+
+केवल UI वाली सुविधा एजेंट के लिए अदृश्य है। केवल actions के साथ पूर्ण UI सुविधा उपयोगकर्ता के लिए अदृश्य है। ऐप-स्टेट के बिना एक सुविधा का मतलब है कि एजेंट इस बात से अनभिज्ञ है कि उपयोगकर्ता क्या कर रहा है। एक हेडलेस ऑपरेशन वैध रूप से एक्शन + निर्देशों के साथ शुरू हो सकता है और बाद में UI/ऐप-स्टेट जोड़ सकता है जब मनुष्यों को इसे ब्राउज़ करने, स्वीकृत करने, कॉन्फ़िगर करने या साझा करने की आवश्यकता होती है।
+
+## SQL में डेटा {#data-in-sql}
+
+सभी एप्लिकेशन स्थिति Drizzle ORM के माध्यम से SQL डेटाबेस में रहती है। स्कीमा प्रदाता-अज्ञेयवादी हैं; समर्थित डेटाबेस, `DATABASE_URL` कॉन्फ़िगरेशन और पोर्टेबिलिटी नियम [Database](/docs/database) में रहते हैं।
+
+कोर SQL स्टोर स्वतः निर्मित हैं और प्रत्येक टेम्पलेट में उपलब्ध हैं:
+
+- `application_state` - अल्पकालिक UI स्थिति (नेविगेशन, ड्राफ्ट, चयन)
+- `settings` — सतत कुंजी-मूल्य कॉन्फिगरेशन
+- `oauth_tokens` — OAuth क्रेडेंशियल
+- `sessions` — प्रमाणीकरण सत्र
+
+```an-schema title="Core SQL stores" summary="Auto-created in every template — the agent and UI both read and write these."
+{
+  "entities": [
+    { "id": "application_state", "name": "application_state", "note": "Ephemeral UI state the agent reads for context", "fields": [
+      { "name": "key", "type": "text", "pk": true, "note": "e.g. 'navigation'" },
+      { "name": "value", "type": "json", "note": "view, selection, drafts" }
+    ] },
+    { "id": "settings", "name": "settings", "note": "Persistent key-value config", "fields": [
+      { "name": "key", "type": "text", "pk": true },
+      { "name": "value", "type": "json" }
+    ] },
+    { "id": "oauth_tokens", "name": "oauth_tokens", "note": "OAuth credentials", "fields": [
+      { "name": "provider", "type": "text", "pk": true },
+      { "name": "token", "type": "text" }
+    ] },
+    { "id": "sessions", "name": "sessions", "note": "Auth sessions", "fields": [
+      { "name": "id", "type": "text", "pk": true },
+      { "name": "userId", "type": "text" }
+    ] }
+  ]
+}
+```
+
+```ts
+// Drizzle schema for domain data
+import { table, text, integer } from "@agent-native/core/db/schema";
+
+export const forms = table("forms", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  schema: text("schema").notNull(), // JSON
+  ownerEmail: text("owner_email"),
+  createdAt: integer("created_at").notNull(),
+});
+```
+
+```bash
+# Core actions for quick database inspection and one-off maintenance
+pnpm action db-schema                                       # show all tables
+pnpm action db-query --sql "SELECT * FROM forms"
+pnpm action db-exec --sql "UPDATE forms SET status = ? WHERE id = ?" --args '["closed","form-1"]'
+# Surgical find/replace on a large text column — sends a diff, not the whole value
+pnpm action db-patch --table documents --column content \
+  --where "id='doc-1'" --find "old heading" --replace "new heading"
+```
+
+प्रोडक्शन एजेंट चैट प्लगइन डिफ़ॉल्ट रूप से कच्चे डेटाबेस को लिखने में सक्षम बनाता है
+(`databaseTools: "write"`) ताकि एजेंट बिना प्रतीक्षा किए ऐप-स्वामित्व वाले डेटा को ठीक कर सकें
+नया टाइप किया गया कार्य। उन लेखों का दायरा प्रमाणित उपयोगकर्ता/संगठन तक होता है। सेट करें
+`databaseTools: "read"` केवल `db-schema` / `db-query` निरीक्षण रखने के लिए, या
+सभी डेटा के लिए `databaseTools: "off"` / `false` टाइप किए गए ऐप actions की आवश्यकता है
+पहुँच.
+
+## एजेंट चैट ब्रिज {#agent-chat-bridge}
+
+UI कभी भी LLM को सीधे कॉल नहीं करता है। जब कोई उपयोगकर्ता "जनरेट चार्ट" या "सारांश लिखें" पर क्लिक करता है, तो UI एजेंट को `postMessage` के माध्यम से एक संदेश भेजता है। एजेंट कार्य करता है - पूर्ण वार्तालाप इतिहास, skills, निर्देशों और पुनरावृत्त करने की क्षमता के साथ।
+
+```ts
+// In a React component — delegate AI work to the agent
+import { sendToAgentChat } from "@agent-native/core/client";
+
+sendToAgentChat({
+  message: "Generate a chart showing signups by source",
+  context: "Dashboard ID: main, date range: last 30 days",
+  submit: true,
+});
+```
+
+LLM इनलाइन क्यों नहीं कॉल करते?
+
+- **एआई गैर-नियतात्मक है।** आपको फीडबैक देने और पुनरावृत्त करने के लिए वार्तालाप प्रवाह की आवश्यकता है - एक-शॉट बटन की नहीं।
+- **संदर्भ मायने रखता है।** एजेंट के पास आपका पूरा कोडबेस, निर्देश, skills और इतिहास होता है। इनलाइन कॉल में ऐसा कुछ भी नहीं होता।
+- **एजेंट और भी बहुत कुछ कर सकता है।** यह actions चला सकता है, वेब ब्राउज़ कर सकता है, कोड संशोधित कर सकता है और कई चरणों को एक साथ जोड़ सकता है।
+- **बिना सोचे-समझे निष्पादन।** क्योंकि सब कुछ एजेंट के माध्यम से होता है, किसी भी ऐप को पूरी तरह से Slack, टेलीग्राम, या किसी अन्य एजेंट से [A2A](/docs/a2a-protocol) के माध्यम से संचालित किया जा सकता है।
+
+## Actions सिस्टम {#actions-system}
+
+जब एजेंट को कुछ जटिल करने की आवश्यकता होती है - API को कॉल करें, डेटा संसाधित करें, डेटाबेस से क्वेरी करें - यह एक **कार्रवाई** चलाता है। Actions, `actions/` में TypeScript फ़ाइलें हैं जो एक डिफ़ॉल्ट `defineAction()` निर्यात करती हैं:
+
+```ts
+// actions/fetch-data.ts
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+export default defineAction({
+  description: "Fetch data from a source API.",
+  schema: z.object({
+    source: z.string().describe("Data source key, e.g. 'signups'"),
+  }),
+  run: async ({ source }) => {
+    const res = await fetch(`https://api.example.com/${source}`);
+    return await res.json();
+  },
+});
+```
+
+एक `defineAction()` कॉल आपको देती है:
+
+- **एजेंट टूल** - एजेंट इसे ज़ॉड-व्युत्पन्न JSON स्कीमा के साथ देखता है और इसे कॉल कर सकता है।
+- **फ्रंटेंड हुक** - `useActionMutation("fetch-data")` पूर्ण TypeScript अनुमान के साथ।
+- **फ्रेमवर्क ट्रांसपोर्ट** - क्लाइंट हुक के पीछे ऑटो-माउंटेड।
+- **CLI** - स्क्रिप्टिंग और एजेंट डेव लूप के लिए `pnpm action fetch-data --source=signups`।
+- **MCP टूल / A2A टूल** - जब MCP सर्वर या A2A सक्षम होता है, तो वही क्रिया वहां भी दिखाई देती है।
+
+समान तर्क, एक परिभाषा, प्रत्येक उपभोक्ता तक स्वचालित रूप से पहुंचाई गई। संपूर्ण संदर्भ के लिए [Actions](/docs/actions) देखें।
+
+## लाइव सिंक {#polling-sync}
+
+डेटाबेस परिवर्तन `useDbSync()` के माध्यम से UI में समन्वयित होते हैं। समान-प्रक्रिया `/_agent-native/events` पर स्ट्रीम लिखती है; `/_agent-native/poll` क्रॉस-प्रोसेस और सर्वर रहित फ़ॉलबैक बना हुआ है। जब एजेंट डेटाबेस (एप्लिकेशन स्थिति, सेटिंग्स, या डोमेन डेटा) को लिखता है, तो एक संस्करण काउंटर बढ़ता है और क्लाइंट प्रासंगिक React क्वेरी कैश को अमान्य कर देता है।
+
+```ts
+// Client: subscribe to agent/UI data changes once near the app shell
+import { useDbSync } from "@agent-native/core/client";
+
+useDbSync({ queryClient });
+```
+
+प्रवाह है:
+
+1. एजेंट एक क्रिया चलाता है जो डेटाबेस पर लिखता है
+2. सर्वर `"action"` या `"settings"` जैसे स्रोत के साथ एक परिवर्तन घटना उत्सर्जित करता है
+3. `useDbSync` इसे SSE या पोलिंग फ़ॉलबैक पर प्राप्त करता है
+4. `useActionQuery` हुक और स्रोत-संस्करण `useQuery` हुक पुनः प्राप्त
+5. घटक पृष्ठ पुनः लोड किए बिना नया डेटा प्रस्तुत करते हैं
+
+```an-diagram title="Live sync flow" summary="An agent write becomes a UI render with no manual refresh — SSE first, polling as the universal fallback."
+{
+  "html": "<div class=\"diagram-sync\"><div class=\"diagram-node\">Agent action<br><small class=\"diagram-muted\">writes to DB</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\">Change event<br><small class=\"diagram-muted\">source: action / settings</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\"><span class=\"diagram-pill accent\">useDbSync</span><small class=\"diagram-muted\">SSE &middot; poll fallback</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\">Query refetch<br><small class=\"diagram-muted\">render, no reload</small></div></div>",
+  "css": ".diagram-sync{display:flex;align-items:center;gap:10px;flex-wrap:wrap}.diagram-sync .diagram-arrow{font-size:22px;line-height:1}.diagram-sync .center{display:flex;flex-direction:column;align-items:center;gap:4px;padding:10px 14px}"
+}
+```
+
+यह सभी परिनियोजन परिवेशों में काम करता है - सर्वर रहित और एज सहित - क्योंकि यह डेटाबेस का उपयोग करता है, इन-मेमोरी स्थिति या फ़ाइल सिस्टम वॉचर्स का नहीं।
+
+## फ़्रेम्स {#frames}
+
+एक _frame_ वह वातावरण है जो आपके ऐप के बगल में एजेंट को होस्ट करता है - स्थानीय रूप से वह एम्बेडेड पैनल है; बादल में यह Builder.io की प्रबंधित सतह है। [Frames](/docs/frames) देखें.
+
+एजेंट-नेटिव ऐप्स में एक एम्बेडेड एजेंट पैनल शामिल होता है जो ऐप UI के साथ AI एजेंट प्रदान करता है। यह वही है जो आर्किटेक्चर को काम करता है: एजेंट को एक कंप्यूटर (डेटाबेस, ब्राउज़र, कोड निष्पादन) की आवश्यकता होती है, और ऐप को एआई कार्य के लिए एजेंट की आवश्यकता होती है।
+
+> **एम्बेडेड एजेंट पैनल** - चैट और वैकल्पिक CLI टर्मिनल प्रत्येक ऐप में बनाया गया है। Claude कोड, Codex, जेमिनी, ओपनकोड और Builder.io को सपोर्ट करता है। स्थानीय स्तर पर चलता है. मुफ़्त और खुला स्रोत.
+>
+> **क्लाउड** - वास्तविक समय सहयोग, दृश्य संपादन, भूमिकाओं और अनुमतियों के साथ किसी भी क्लाउड पर तैनात करें। टीमों के लिए सर्वश्रेष्ठ.
+
+## संदर्भ जागरूकता {#context-awareness}
+
+एजेंट को हमेशा पता होता है कि उपयोगकर्ता क्या देख रहा है। UI प्रत्येक रूट परिवर्तन पर एप्लिकेशन-स्टेट के लिए एक `navigation` कुंजी लिखता है। एजेंट कार्रवाई करने से पहले इसे `view-screen` कार्रवाई के माध्यम से पढ़ता है।
+
+उदाहरण के लिए, जब आप एक ईमेल थ्रेड खोलते हैं तो UI एक पंक्ति को ऊपर उठाता है:
+
+```json
+{ "key": "navigation", "value": { "view": "thread", "threadId": "th_abc123" } }
+```
+
+UI इसे मार्ग परिवर्तन पर लिखता है; एजेंट कोई भी कार्रवाई करने से पहले इसे (`view-screen` के माध्यम से) पढ़ता है, इसलिए यह हमेशा जानता है कि आप किस थ्रेड - या चार्ट, या स्लाइड - पर ध्यान केंद्रित कर रहे हैं।
+
+पूर्ण पैटर्न के लिए [Context Awareness](/docs/context-awareness) देखें: नेविगेशन स्थिति, व्यू-स्क्रीन, नेविगेट कमांड और घबराहट की रोकथाम।
+
+## एक क्रिया, अनेक सतह {#protocols}
+
+एक डोमेन ऑपरेशन को एक बार क्रिया के रूप में कार्यान्वित करें; ढांचा इसे प्रत्येक उपभोक्ता के सामने उजागर करता है। वही `defineAction()` एक एजेंट टूल, एक टाइपसेफ UI हुक, एक HTTP एंडपॉइंट, एक CLI कमांड, एक MCP टूल और एक A2A टूल बन जाता है, जिसमें वैकल्पिक `link`, `mcpApp`, या स्पष्ट देशी-विजेट मेटाडेटा केवल तब जोड़ा जाता है जब किसी सतह को इसकी आवश्यकता होती है। Skills और निर्देश व्यवहार को कवर करते हैं।
+
+पूर्ण प्रोटोकॉल/सतह मैट्रिक्स (MCP सर्वर और OAuth, MCP ऐप्स, A2A, डीप लिंक, देशी चैट विजेट, AgentChatRuntime कनेक्टर, एजेंट वेब और ACP और A2UI के लिए एडाप्टर क्षितिज) के लिए, और उत्पाद आकार चुनने के लिए - हेडलेस, रिच चैट, एम्बेडेड साइडकार, या पूर्ण ऐप - देखें [Agent Surfaces](/docs/agent-surfaces).
+
+## एजेंट कोड को संशोधित करता है {#agent-modifies-code}
+
+यह एक सुविधा है, बग नहीं। एजेंट ऐप के स्रोत कोड को सुरक्षित रूप से संपादित कर सकता है: घटक, मार्ग, शैलियाँ, actions।
+
+तोड़ने के लिए कोई साझा कोडबेस नहीं है। आप ऐप के मालिक हैं, और एजेंट समय के साथ इसे आपके लिए विकसित करता है:
+
+1. एक टेम्प्लेट फोर्क करें (उदाहरण के लिए एनालिटिक्स टेम्प्लेट)
+2. एजेंट से पूछकर इसे अनुकूलित करें
+3. "समूह विश्लेषण के लिए एक नया चार्ट प्रकार जोड़ें" - एजेंट इसे बनाता है
+4. "हमारे स्ट्राइप खाते से कनेक्ट करें" - एजेंट एकीकरण लिखता है
+5. आपका ऐप मैन्युअल विकास के बिना सुधार करता रहता है
+
+## डिफ़ॉल्ट रूप से पोर्टेबल {#hosting-agnostic}
+
+दो वास्तुशिल्प नियम ऐप्स को डेटाबेस और होस्ट पर पोर्टेबल रखते हैं:
+
+- **डेटाबेस-अज्ञेयवादी।** `@agent-native/core/db/schema` के साथ स्कीमा लिखें और Drizzle की पोर्टेबल क्वेरी DSL के साथ पढ़ें/लिखें ताकि वही कोड किसी भी समर्थित प्रदाता पर चले। कच्चे SQL का उपयोग केवल एडिटिव माइग्रेशन या एकमुश्त रखरखाव के लिए करें, पैरामीटरयुक्त और बोली-अज्ञेयवादी रखा जाए। [Database](/docs/database) देखें.
+- **होस्टिंग-अज्ञेयवादी।** सर्वर Nitro पर चलता है और किसी भी परिनियोजन लक्ष्य को संकलित करता है। सर्वर रूट या प्लगइन्स में कभी भी नोड-विशिष्ट APIs (`fs`, `child_process`, `path`) का उपयोग न करें, और कभी भी लगातार सर्वर प्रक्रिया न मानें - सर्वर रहित और एज स्टेटलेस हैं, इसलिए सभी स्थिति को SQL में रखें। [Deployment](/docs/deployment) देखें.
+
+## कार्यस्थान {#workspace}
+
+प्रत्येक उपयोगकर्ता को एक व्यक्तिगत **कार्यक्षेत्र** मिलता है - निर्देश, skills, मेमोरी, कस्टम उप-एजेंट, निर्धारित कार्य और कनेक्टेड MCP सर्वर - सभी फ़ाइलों के बजाय SQL में संग्रहीत होते हैं। यह प्रति उपयोगकर्ता एक कंटेनर को घुमाए बिना बहु-किरायेदार SaaS के अंदर Claude-कोड-स्तरीय अनुकूलन को व्यवहार्य बनाता है। [Workspace](/docs/workspace) देखें.
+
+## संबंधित भवन ब्लॉक {#building-blocks}
+
+ये एक ही अनुबंध के शीर्ष पर बैठते हैं और उनके अपने गहरे गोता होते हैं:
+
+- **[Dispatch](/docs/dispatch)** - कार्यक्षेत्र नियंत्रण विमान: साझा इनबॉक्स, रहस्य वॉल्ट, निर्धारित कार्य, और एक ऑर्केस्ट्रेटर जो A2A पर विशेषज्ञ ऐप्स को सौंपता है।
+- **[Extensions](/docs/extensions)** - सैंडबॉक्स्ड Alpine.js मिनी-ऐप्स एजेंट रनटाइम पर बनाता है, कोई स्रोत परिवर्तन या माइग्रेशन नहीं।
+- **[A2A Protocol](/docs/a2a-protocol)** - एक ही कार्यक्षेत्र में ऐप्स JSON-RPC पर एक-दूसरे को कैसे खोजते हैं और कॉल करते हैं।
+
+## आपको मुफ़्त में क्या मिलता है {#what-you-get-for-free}
+
+फ्रेमवर्क को अपनाना ज्यादातर इसलिए मूल्यवान है क्योंकि आपको निर्माण करना बंद कर देना चाहिए। जैसे ही आपका ऐप छह नियमों का पालन करता है, आपको यह विरासत में मिलता है:
+
+- **एक क्रिया = प्रत्येक सतह।** `defineAction()` के साथ परिभाषित प्रत्येक क्रिया एक साथ एक एजेंट टूल, एक टाइपसेफ फ्रंटएंड हुक (`useActionQuery` / `useActionMutation`), एक फ्रेमवर्क-स्वामित्व वाली HTTP ट्रांसपोर्ट, एक CLI कमांड, बाहरी क्लाइंट के लिए एक MCP टूल और अन्य एजेंट-मूल ऐप्स के लिए एक A2A टूल है। वैकल्पिक `link` और `mcpApp` मेटाडेटा दूसरे कार्यान्वयन के बिना डीप लिंक और MCP ऐप्स UI जोड़ते हैं।
+- **प्रति उपयोगकर्ता एक पूर्ण कार्यक्षेत्र।** Skills, साझा `LEARNINGS.md`, व्यक्तिगत `memory/MEMORY.md`, `AGENTS.md`, कस्टम उप-एजेंट, निर्धारित नौकरियां, कनेक्टेड MCP सर्वर - सभी SQL-समर्थित, कोई डेव-बॉक्स आवश्यक नहीं है। [Workspace](/docs/workspace) देखें.
+- **ड्रॉप-इन React घटक।** `<AgentPanel />` और `<AgentSidebar />` आपके ऐप में कहीं भी चैट + वर्कस्पेस प्रस्तुत करते हैं। [Drop-in Agent](/docs/drop-in-agent) देखें.
+- **BYO एजेंट चैट रनटाइम।** वही चैट UI OpenAI एजेंट, OpenAI प्रतिक्रियाएं, Claude एजेंट SDK, वर्सेल AI SDK, AG-UI, या आपकी अपनी सामान्यीकृत HTTP स्ट्रीम के शीर्ष पर बैठ सकती है। [Native Chat UI](/docs/native-chat-ui#byo-agent-runtimes) देखें.
+- **एजेंट और UI के बीच लाइव सिंक।** समान प्रक्रिया `/_agent-native/events` पर तुरंत स्ट्रीम लिखती है; एक हल्का पोल सर्वर रहित, क्रॉन और क्रॉस-प्रोसेस लेखन को अभिसरण रखता है। actions को म्यूट करने से एक्शन-समर्थित क्वेरीज़ स्वचालित रूप से अमान्य हो जाती हैं, इसलिए एजेंट द्वारा बनाए गए रिकॉर्ड मैन्युअल रीफ्रेश के बिना दिखाई देते हैं। नीचे [Live Sync](#polling-sync) देखें।
+- **प्रमाणीकरण, संगठन, RBAC.** प्रत्येक टेम्पलेट के लिए संगठन/सदस्यों/भूमिकाओं के साथ बेहतर प्रमाणीकरण को शामिल किया गया है। [Authentication](/docs/authentication) देखें.
+- **संदर्भ जागरूकता।** एजेंट हमेशा जानता है कि उपयोगकर्ता `navigation` ऐप-स्टेट कुंजी के माध्यम से क्या देख रहा है। [Context Awareness](/docs/context-awareness) देखें.
+- **MCP क्लाइंट + सर्वर, दोनों दिशाएं।** ऐप MCP सर्वर (स्थानीय, रिमोट, हब-शेयर्ड) को ग्रहण करता है _और_ अपने स्वयं के actions को MCP सर्वर के रूप में प्रदर्शित करता है। [MCP Clients](/docs/mcp-clients) और [MCP Protocol](/docs/mcp-protocol) देखें।
+- **अंतर-ऐप प्रतिनिधिमंडल।** विभिन्न ऐप्स में एजेंट [A2A](/docs/a2a-protocol) पर बात करते हैं। समान-मूल परिनियोजन JWT को छोड़ें; क्रॉस-ओरिजिन एक साझा `A2A_SECRET` का उपयोग करता है।
+- **उप-एजेंट टीमें।** एक उप-एजेंट को अपने स्वयं के थ्रेड और टूल के साथ तैयार करें, जो चैट में एक चिप इनलाइन के रूप में सामने आया। [Agent Teams](/docs/agent-teams) देखें.
+- **पोर्टेबिलिटी।** कोई भी Drizzle-समर्थित SQL डेटाबेस, कोई भी Nitro-संगत होस्ट (नोड, वर्कर्स, नेटलिफाई, वर्सेल, डेनो, लैम्ब्डा, बन)।
+
+यही वह "और बाकी सब कुछ" है जिसे आप अन्यथा स्वयं ही जोड़ रहे होते।
+
+## गहरा गोता {#deep-dives}
+
+विशिष्ट पैटर्न पर विस्तृत मार्गदर्शन के लिए:
+
+- [What Is Agent-Native?](/docs/what-is-agent-native) - दृष्टि और दर्शन
+- [Context Awareness](/docs/context-awareness) - नेविगेशन स्थिति, व्यू-स्क्रीन, नेविगेट कमांड
+- [Skills Guide](/docs/skills-guide) - फ्रेमवर्क skills, डोमेन skills, कस्टम skills बनाना
+- [Native Chat UI](/docs/native-chat-ui) - क्रिया-घोषित तालिकाएँ, चार्ट और BYO रनटाइम मुद्रा
+- [Agent Surfaces](/docs/agent-surfaces) - हेडलेस, रिच चैट, एम्बेडेड साइडकार, और पूर्ण-ऐप पथ
+- [A2A Protocol](/docs/a2a-protocol) — एजेंट-टू-एजेंट संचार
+- [Multi-App Workspace](/docs/multi-app-workspace) - साझा प्रमाणीकरण, skills, घटकों और क्रेडेंशियल्स के साथ एक मोनोरेपो में कई ऐप्स होस्ट करें