@agent-native/core 0.76.5 → 0.76.6

package/corpus/core/docs/content/locales/hi-IN/drop-in-agent.md

@@ -0,0 +1,260 @@
+---
+title: "ड्रॉप-इन एजेंट"
+description: "एजेंट चैट + वर्कस्पेस को <AgentPanel>, <AgentSidebar>, और sentToAgentChat() के साथ किसी भी React ऐप में माउंट करें।"
+---
+
+# ड्रॉप-इन एजेंट
+
+> **डेवलपर पेज।** यह पेज एजेंट को React ऐप में एम्बेड करने वाले डेवलपर्स के लिए है। एजेंट के साथ काम करने के अंतिम-उपयोगकर्ता अनुभव के लिए, [Using Your Agent](/docs/using-your-agent) देखें।
+
+आपको शुरुआत से एजेंट-नेटिव बनाने की आवश्यकता नहीं है। एजेंट चैट, वर्कस्पेस टैब, CLI टर्मिनल, वॉयस इनपुट, और सभी संबंधित बुनियादी ढांचे को मुट्ठी भर React घटकों के रूप में शिप किया जाता है जिन्हें आप किसी भी ऐप में डालते हैं।
+
+> **पूर्वावश्यकता:** सर्वर को `agent-chat-plugin` चलाना होगा (यह प्रत्येक टेम्पलेट में स्वचालित रूप से माउंट होता है)। यदि आप शून्य से शुरू कर रहे हैं, तो [Server](/docs/server) देखें।
+>
+> ट्यूटोरियल के बजाय सार्वजनिक API मानचित्र की आवश्यकता है? [Component API](/docs/components) देखें.
+
+## घटक एक नज़र में {#components}
+
+| घटक                   | यह क्या है                                                                                 | इसका उपयोग तब करें जब                                         |
+| --------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
+| `<AgentSidebar>`      | आपके रूट ऐप लेआउट को लपेटता है और पूर्ण एजेंट युक्त एक टॉगल करने योग्य साइड पैनल जोड़ता है | आप चाहते हैं कि एजेंट आपके ऐप के साथ हर स्क्रीन पर उपलब्ध हो  |
+| `<AgentToggleButton>` | `<AgentSidebar>` को खोलता/बंद करता है (इसे अपने हेडर में रखें)                             | `<AgentSidebar>` के साथ युग्मित करें                          |
+| `<AgentPanel>`        | कच्चा पैनल स्वयं - चैट + CLI + कार्यस्थान टैब                                              | आप लेआउट, या एक समर्पित एजेंट पेज पर पूर्ण नियंत्रण चाहते हैं |
+| `<AgentChatSurface>`  | एक पूर्व-वायर्ड पैनल/पेज चैट सतह                                                           | आप साइडबार रैपर के बिना चैट करना चाहते हैं                    |
+| `<AssistantChat>`     | संगीतकार/इतिहास हुक के साथ निचले स्तर का चैट रेंडरर                                        | आपको मानक वार्तालाप UI                                        |
+| `sendToAgentChat()`   | प्रोग्रामेटिक रूप से चैट पर एक संदेश भेजें                                                 | एक बटन जो इनलाइन चलने के बजाय एजेंट को काम सौंपता है          |
+| `useActionMutation()` | किसी क्रिया के चारों ओर टाइपसेफ फ्रंटएंड रैपर                                              | UI को वही ऑपरेशन चलाने की ज़रूरत है जो एक एजेंट टूल चलाएगा    |
+
+ये सभी `@agent-native/core/client` से निर्यात किए जाते हैं।
+
+```an-diagram title="The mount model" summary="<AgentSidebar> wraps your existing layout. Your routes render in the main area; the agent panel mounts beside them. <AgentPanel> is the same panel without the wrapper."
+{
+  "html": "<div class=\"diagram-mount\"><div class=\"diagram-box sidebar\" data-rough><span class=\"diagram-pill accent\">&lt;AgentSidebar&gt;</span><div class=\"inner\"><div class=\"diagram-node main\">Your app<br><small class=\"diagram-muted\">children: header + &lt;Outlet/&gt;</small></div><div class=\"diagram-node panel\">Agent panel<br><small class=\"diagram-muted\">chat &middot; CLI &middot; workspace</small></div></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&harr;</div><div class=\"diagram-card alt\"><span class=\"diagram-pill\">&lt;AgentPanel&gt;</span><small class=\"diagram-muted\">same panel, no wrapper &mdash; you own the layout</small></div></div>",
+  "css": ".diagram-mount{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-mount .sidebar{display:flex;flex-direction:column;gap:8px;padding:14px}.diagram-mount .inner{display:flex;gap:10px}.diagram-mount .main{flex:2}.diagram-mount .panel{flex:1}.diagram-mount .alt{display:flex;flex-direction:column;gap:6px;padding:14px}.diagram-mount .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+## 80% मामला: `<AgentSidebar>` {#sidebar}
+
+सबसे आम सेटअप एक साइडबार है जो किसी भी स्क्रीन पर दाईं ओर से खुलता है।
+अपने मौजूदा रूट लेआउट को `<AgentSidebar>` के साथ लपेटें; जिसे भी आप
+बच्चे मुख्य ऐप क्षेत्र में रहते हैं। एजेंट चैट साइड पैनल है।
+
+```an-annotated-code title="Wrapping the root layout with <AgentSidebar>"
+{
+  "filename": "app/root.tsx",
+  "language": "tsx",
+  "code": "import { Outlet } from \"react-router\";\nimport { AgentSidebar, AgentToggleButton } from \"@agent-native/core/client\";\n\nexport default function Root() {\n  return (\n    <AgentSidebar\n      emptyStateText=\"How can I help?\"\n      suggestions={[\n        \"Summarize my inbox\",\n        \"Draft a reply to the latest email\",\n        \"Show me yesterday's signup numbers\",\n      ]}\n      dynamicSuggestions\n      defaultSidebarWidth={420}\n      position=\"right\"\n    >\n      <header>\n        <AgentToggleButton />\n      </header>\n\n      <main>\n        <Outlet />\n      </main>\n    </AgentSidebar>\n  );\n}",
+  "annotations": [
+    { "lines": "6", "label": "Wrapper", "note": "`<AgentSidebar>` wraps your whole layout. It adds the toggleable side panel; everything you pass as children stays in the main app area." },
+    { "lines": "8-12", "label": "Starter prompts", "note": "`suggestions` render as clickable chips on the empty chat." },
+    { "lines": "13", "label": "Context-aware chips", "note": "`dynamicSuggestions` merges screen-aware prompts (e.g. \"Summarize this selection\") with your static ones. On by default." },
+    { "lines": "18-20", "label": "Toggle button", "note": "Put `<AgentToggleButton />` anywhere in your header to open and close the panel." },
+    { "lines": "22-24", "label": "Your app", "note": "`<Outlet/>` (your routes) renders in the main area, untouched." }
+  ]
+}
+```
+
+बस इतना ही। उपयोगकर्ता के पास अब प्रत्येक पृष्ठ पर एक टॉगल करने योग्य एजेंट है - चैट इतिहास, कार्यक्षेत्र टैब, CLI टर्मिनल, वॉयस इनपुट और एक फुलस्क्रीन मोड के साथ। स्थिति `localStorage` के माध्यम से पुनः लोड करने पर बनी रहती है।
+
+### प्रॉप्स
+
+- **`children`** - आपके ऐप का सामान्य लेआउट और रूट। मुख्य क्षेत्र में प्रस्तुत; एजेंट पैनल डेस्कटॉप पर इसके बगल में और मोबाइल/फुलस्क्रीन पर इसके ऊपर लगा होता है।
+- **`emptyStateText`** — जब चैट में कोई संदेश न हो तो अभिवादन दिखाया जाता है। डिफ़ॉल्ट: `"How can I help you?"`.
+- **`suggestions`** - खाली होने पर स्टार्टर संकेत क्लिक करने योग्य चिप्स के रूप में प्रस्तुत किया जाता है।
+- **`dynamicSuggestions`** - संदर्भ-जागरूक प्रॉम्प्ट चिप्स को `suggestions` के साथ विलय कर दिया गया। डिफ़ॉल्ट रूप से सक्षम; केवल स्थिर सुझाव दिखाने के लिए `false` पास करें, या अनुकूलित करने के लिए `{ max, includeStatic, getSuggestions }` पास करें।
+- **`defaultSidebarWidth`** - प्रारंभिक पिक्सेल चौड़ाई (केवल माउंट; उपयोगकर्ता का आकार और सहेजा गया मान ओवरराइड)। डिफ़ॉल्ट: `380`.
+- **`position`** — `"left"` या `"right"`। डिफ़ॉल्ट: `"right"`.
+- **`defaultOpen`** — क्या साइडबार खुलना शुरू होता है (केवल डेस्कटॉप)। डिफ़ॉल्ट: `false`.
+
+## अन्य 20%: `<AgentPanel>` {#panel}
+
+जब आपको लेआउट पर पूर्ण नियंत्रण की आवश्यकता होती है - एक समर्पित `/chat` मार्ग, आपके द्वारा प्रबंधित साइड कॉलम में एक एम्बेडेड पैनल, या एक पॉपअप - सीधे `<AgentPanel>` प्रस्तुत करें:
+
+```tsx
+// app/routes/agent.tsx
+import { AgentPanel } from "@agent-native/core/client";
+
+export default function AgentRoute() {
+  return (
+    <div className="h-screen">
+      <AgentPanel defaultMode="chat" className="h-full" />
+    </div>
+  );
+}
+```
+
+`<AgentPanel>` आपको साइडबार रैपर, कोलैप्स बटन या किसी भी स्टेट पर्सिस्टेंस के बिना रॉ टैब (चैट / CLI / वर्कस्पेस) देता है। जहां चाहो वहां रख दो; आप लेआउट संभालें.
+
+### चयनित प्रॉप्स
+
+- **`defaultMode`** — `"chat"` या `"cli"`। डिफ़ॉल्ट: `"chat"`.
+- **`className`** - बाहरी कंटेनर के लिए CSS वर्ग।
+- **`onCollapse`** - यदि प्रदान किया गया है, तो हेडर में एक संक्षिप्त बटन दिखाई देता है।
+- **`isFullscreen`** / **`onToggleFullscreen`** - यदि आप Claude-शैली केंद्रित कॉलम चाहते हैं तो बाहरी पूर्णस्क्रीन स्थिति को तार दें।
+- **`storageKey`** — `localStorage` कुंजियों के लिए नामस्थान। तब उपयोगी होता है जब आप एक ही पेज में एकाधिक पैनल (अलग-अलग ऐप इंस्टेंस या वर्कस्पेस) प्रस्तुत करते हैं।
+
+पूर्ण प्रॉप्स: `@agent-native/core/client` में `AgentPanelProps`।
+
+## प्रोग्रामेटिक संदेश: `sendToAgentChat()` {#send}
+
+एक बटन जो एजेंट को काम सौंपता है (इनलाइन `llm()` कॉल चलाने के बजाय - [ladder](/docs/what-is-agent-native#the-ladder) से एंटी-पैटर्न):
+
+```tsx
+import { sendToAgentChat } from "@agent-native/core/client";
+
+<Button
+  onClick={() =>
+    sendToAgentChat({
+      message: "Generate a chart showing signups by source",
+      context: `Dashboard ID: ${dashboardId}, date range: last 30 days`,
+      submit: true,
+    })
+  }
+>
+  Generate chart
+</Button>;
+```
+
+### विकल्प
+
+- **`message`** — चैट में दिखाया गया दृश्य संकेत।
+- **`context`** - छिपा हुआ संदर्भ प्रॉम्प्ट से जुड़ा हुआ है (चयनित पाठ, कर्सर स्थिति, वर्तमान इकाई आईडी - कुछ भी एजेंट को पता होना चाहिए लेकिन उपयोगकर्ता को दो बार नहीं देखना चाहिए)।
+- **`submit`** - `true` ऑटो-रन के लिए, `false` प्रीफिल करने के लिए लेकिन प्रतीक्षा करें। प्रोजेक्ट डिफ़ॉल्ट का उपयोग करना छोड़ें.
+- **`newTab`** — इस प्रॉम्प्ट के लिए एक अलग चैट थ्रेड बनाएं।
+- **`background`** - `newTab` के साथ, नए थ्रेड पर ध्यान केंद्रित किए बिना चलाएं। छिपे हुए रन को `RunsTray` में ट्रैक किया जाता है।
+- **`openSidebar`** - पृष्ठभूमि/मूक प्रेषण के लिए `false` पर सेट करें। डिफ़ॉल्ट रूप से साइडबार खुलता है ताकि उपयोगकर्ता प्रतिक्रिया देख सके।
+- **`type`** — `"content"` (डिफ़ॉल्ट) कार्य को एम्बेडेड ऐप एजेंट में रखता है। `"code"` कोड-संपादन फ़्रेम तक रूट करता है (एजेंट-लिखित कोड परिवर्तनों के लिए, [Frames](/docs/frames) देखें)।
+
+`sendToAgentChat` एक स्थिर `tabId` लौटाता है जिसका उपयोग आप चैट रन को ट्रैक करने के लिए कर सकते हैं।
+
+मौन कार्य के लिए, `newTab`, `background`, और `openSidebar: false` को जोड़ें:
+
+```ts
+sendToAgentChat({
+  message: "Summarize the selected thread and save the summary",
+  context: `Thread id: ${threadId}`,
+  submit: true,
+  newTab: true,
+  background: true,
+  openSidebar: false,
+});
+```
+
+यह अभी भी टूल, actions, थ्रेड स्टेट और रन के साथ एक पूर्ण एजेंट रन है
+ट्रैकिंग। यह उपयोगकर्ता की वर्तमान साइडबार स्थिति से फोकस चुराता नहीं है।
+
+जब उसी रूट को MCP ऐप के रूप में एम्बेड किया जाता है, सबमिट किया जाता है
+`sendToAgentChat()` कॉल होस्ट चैट पर अग्रेषित की जाती हैं जहां समर्थित है; देखें
+MCP ऐप ब्रिज व्यवहार के लिए [Client](/docs/client#sendtoagentchat)।
+
+यदि आप लोडिंग स्थिति चाहते हैं, तो `useSendToAgentChat()` हुक का उपयोग करें - यह `send` और `isGenerating` दोनों लौटाता है:
+
+```ts
+import { useSendToAgentChat } from "@agent-native/core/client";
+
+const { send, isGenerating } = useSendToAgentChat();
+```
+
+## जब स्टॉक साइडबार उपयुक्त न हो {#custom-chat-ui}
+
+`<AgentSidebar>` और `<AgentPanel>` अधिकांश ऐप्स को कवर करते हैं। जब आपको
+एजेंट के इर्द-गिर्द लेआउट, या आप किसी एजेंट के साथ बातचीत को सशक्त बनाना चाहते हैं
+आपने कहीं और निर्माण किया है, एक परत नीचे गिराएं - लेकिन ढांचे को अपने स्वामित्व में रखें
+रनटाइम, actions, और SQL-समर्थित स्थिति:
+
+- **मानक रनटाइम के आसपास क्रोम का स्वामित्व।** के लिए `<AgentChatSurface>` का उपयोग करें
+  एक समर्पित चैट मार्ग, या `<AssistantChat>` जब आप कस्टम हेडर चाहते हैं,
+  टैब, और मानक वार्तालाप के आसपास खाली स्थितियाँ। पूर्ण परत मानचित्र—
+  प्रत्येक घटक, हुक, कंपोज़र और एडाप्टर, आयात पथ के साथ - में रहता है
+  [Component API](/docs/components#agent-chat-ui).
+- **अपना स्वयं का एजेंट रनटाइम लाएँ।** यदि आपने कोई एजेंट कहीं और बनाया है तो उसे लाना चाहिए
+  बातचीत को सशक्त बनाएं जबकि Agent-Native कंपोजर, ट्रांसक्रिप्ट, टूल रखता है
+  कार्ड, अनुमोदन और मूल विजेट, एक `AgentChatRuntime` पास करें
+  `<AssistantChat runtime={...} />`. कनेक्टर्स
+  (`createHttpAgentChatRuntime()` और OpenAI / Claude / Vercel AI / AG-UI
+  सहायक) और इवेंट अनुबंध को
+  [Native Chat UI — BYO agent runtimes](/docs/native-chat-ui#byo-agent-runtimes).
+
+आप जो भी परत चुनें, actions और SQL-समर्थित ऐप स्थिति को अनुबंध के रूप में रखें,
+और उत्पाद UI से सीधे `/_agent-native/agent-chat` पर पोस्ट करने से बचें। यदि ए
+वास्तविक कस्टम सतह के लिए नामित सहायक गायब है, इसलिए पहले उस सहायक को जोड़ें
+क्लाइंट कोड दूसरा, तदर्थ परिवहन नहीं सीखता।
+
+## UI से टाइपसेफ actions: `useActionMutation()` {#use-action-mutation}
+
+जब UI को समान ऑपरेशन चलाने की आवश्यकता होती है तो एक एजेंट टूल चलेगा - [ladder](/docs/what-is-agent-native#rung-three) का क्रमांक 3 - `useActionMutation` का उपयोग करें:
+
+```tsx
+import { useActionMutation } from "@agent-native/core/client";
+
+const { mutate, isPending } = useActionMutation("reply-to-email");
+
+<Button onClick={() => mutate({ emailId, body: "Thanks!" })}>
+  Send Reply
+</Button>;
+```
+
+टाइप-सुरक्षित तर्क आपके `defineAction()` में ज़ोड स्कीमा से आते हैं। संपूर्ण कार्य प्रणाली के लिए [Actions](/docs/actions) देखें।
+
+```an-callout
+{
+  "tone": "decision",
+  "body": "**`useActionMutation` vs `sendToAgentChat`.** Run the operation directly with `useActionMutation` when the user clicked a deterministic button (\"Send reply\"). Hand it to `sendToAgentChat` when the work needs the agent's reasoning, tools, or multi-step planning. Never call an inline `llm()` from UI — that is rung 1 of the [ladder](/docs/what-is-agent-native#the-ladder)."
+}
+```
+
+## चयन + कर्सर जागरूकता {#selection}
+
+एजेंट यह देख सकता है कि उपयोगकर्ता ने क्या चुना है - टेक्स्ट, सेल, स्लाइड, संपर्क - एप्लिकेशन स्थिति में `navigation` और `selection` कुंजियों के माध्यम से। खाली चैट उन कुंजियों का उपयोग गतिशील सुझाव देने के लिए भी करती है जैसे "इस चयन को सारांशित करें" या "इस स्लाइड को सुधारें" जब वर्तमान स्क्रीन उन्हें प्रासंगिक बनाती है। यदि आप चाहते हैं कि Cmd-I (या समान) संदर्भ के रूप में चैट में एक चयनित रेंज भेजे, तो [Context Awareness](/docs/context-awareness) देखें।
+
+## यह सब एक साथ रखना {#putting-it-together}
+
+एक सामान्य ड्रॉप-इन सेटअप:
+
+```tsx
+// app/root.tsx
+import {
+  AgentSidebar,
+  AgentToggleButton,
+  sendToAgentChat,
+} from "@agent-native/core/client";
+
+export default function Root() {
+  return (
+    <AgentSidebar suggestions={["Draft a reply", "Summarize selection"]}>
+      <Header>
+        <AgentToggleButton />
+      </Header>
+
+      <Main>
+        <YourRoutes />
+      </Main>
+    </AgentSidebar>
+  );
+}
+```
+
+```tsx
+// Anywhere else in the app
+<Button
+  onClick={() =>
+    sendToAgentChat({
+      message: "Summarize this thread",
+      context: `Thread id: ${threadId}`,
+      submit: true,
+    })
+  }
+>
+  Summarize
+</Button>
+```
+
+उपयोगकर्ता हेडर में एक चैट बटन देखता है, उसे खोल सकता है, और एजेंट से बात कर सकता है। आपके बटन एक-शॉट LLM कॉल चलाने के बजाय उसी एजेंट को सौंप देते हैं।
+
+## आगे क्या
+
+- [**Actions**](/docs/actions) - `defineAction()` और `useActionMutation()`
+- [**Context Awareness**](/docs/context-awareness) - चयन, नेविगेशन, व्यू-स्क्रीन
+- [**Workspace**](/docs/workspace) - वर्कस्पेस टैब में क्या शामिल है (skills, मेमोरी, MCP सर्वर, शेड्यूल किए गए कार्य)
+- [**Voice Input**](/docs/voice-input) - चैट कंपोजर में माइक्रोफोन

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

@@ -0,0 +1,65 @@
+---
+title: "टिकाऊ बायोडाटा"
+description: "जब एक होस्ट किया गया एजेंट रन बाधित होता है और फिर से शुरू होता है, तो पूर्ण किए गए साइड-इफेक्टिंग टूल कॉल दोबारा नहीं चलते हैं - टिकाऊ लेजर से प्राप्त टूल-कॉल जर्नल डुप्लिकेट सेंड, शुल्क और टिकट को ब्लॉक करता है।"
+---
+
+# टिकाऊ बायोडाटा
+
+> **यह किसके लिए है:** कोई भी जो यह समझना चाहता है कि फ्रेमवर्क कैसे चलता है
+> पुनर्प्राप्ति डुप्लिकेट दुष्प्रभावों से बचाती है। यह अंतर्निहित व्यवहार है - वहाँ
+> तार लगाने के लिए कुछ भी नहीं।
+
+होस्ट किए गए एजेंट रन बाधित हो जाते हैं: एक सर्वर रहित फ़ंक्शन अपने हार्ड टाइमआउट को मध्य-धारा में हिट करता है, एक गेटवे 45 पर कनेक्शन बंद कर देता है, एक सॉकेट हैंग हो जाता है, प्लेटफ़ॉर्म कोल्ड-स्टार्ट होता है। वार्तालाप उपसर्ग को सहेजने और LLM कॉल को फिर से चलाने ("जहां आपने छोड़ा था वहां से जारी रखें") द्वारा फ्रेमवर्क पहले से ही इनसे उबर जाता है। लेकिन केवल पुनर्प्राप्ति में ही तेज धार होती है: यदि बाधित प्रयास **पहले ही एक ईमेल भेज चुका है या टिकट बना चुका है**, तो एक अनुभवहीन बायोडाटा इसे फिर से कर सकता है।
+
+टिकाऊ बायोडाटा उस अंतर को पाट देता है। फिर से शुरू करने पर, फ्रेमवर्क को पता चलता है कि कौन सा साइड-इफेक्टिंग टूल कॉल पहले ही पूरा हो चुका है और उन्हें दो परतों पर फिर से चलाने से इंकार कर देता है।
+
+```an-diagram title="Two layers block duplicate side effects on resume" summary="The journal reads the durable ledger and classifies prior calls; layer 1 tells the model, layer 2 hard-blocks a re-dispatched write that matches a completed entry."
+{
+  "html": "<div class=\"diagram-durable\"><div class=\"diagram-box\" data-rough>Run-event ledger<br><small class=\"diagram-muted\">tool_start / tool_done</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\" data-rough><strong>Tool-call journal</strong><small class=\"diagram-ok\">completed = start+done</small><small class=\"diagram-warn\">interrupted = start, no done</small></div><div class=\"diagram-col\"><div class=\"diagram-pill\">Layer 1 · prompt note &rarr; model</div><div class=\"diagram-pill accent\">Layer 2 · hard-block re-dispatched write</div></div></div>",
+  "css": ".diagram-durable{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-durable .diagram-col{display:flex;flex-direction:column;gap:8px}.diagram-durable .diagram-arrow{font-size:22px;line-height:1}.diagram-durable .center{display:flex;flex-direction:column;align-items:center;gap:4px}"
+}
+```
+
+## टूल-कॉल जर्नल {#journal}
+
+जर्नल एक **टिकाऊ रन-इवेंट लेजर पर शुद्ध रूप से पढ़ा जाने वाला** है - हॉट पाथ में कोई नया रिकॉर्डिंग हुक नहीं है। यह वर्तमान मोड़ के लिए पहले से रिकॉर्ड किए गए टूल कॉल को वर्गीकृत करता है:
+
+- **पूर्ण** - मिलान वाले `tool_done` के साथ एक `tool_start`। कॉल चली, उसका साइड इफेक्ट हुआ और उसका रिजल्ट रिकॉर्ड हो गया. **दोबारा न चलाएं.**
+- **बाधित** - एक `tool_start` जिसका मिलान **नहीं** `tool_done` से हो रहा है। कॉल शुरू हुई, उसका दुष्प्रभाव पड़ा या नहीं पड़ा और व्यवधान ने परिणाम खा लिया। परिणाम अज्ञात.
+
+इससे मेल खाता है कि कहीं और टिकाऊ मोड़ कैसे बनाए जाते हैं: एक `tool_done` एक ही टूल नाम (FIFO प्रति टूल) के लिए सबसे पुराने अभी भी खुले `tool_start` के साथ जुड़ता है। एक `clear` ईवेंट (खारिज किया गया आंशिक आउटपुट) प्रति-टर्न टैली को रीसेट करता है ताकि छोड़े गए आंशिक भाग फैंटम ओपन कॉल न छोड़ें।
+
+## परत 1: प्रॉम्प्ट-स्तरीय जर्नल नोट {#prompt-note}
+
+जब कोई रन फिर से शुरू होता है (सॉफ्ट टाइमआउट, गेटवे टाइमआउट, या कोई पुन: प्रारंभ करने योग्य ट्रांसपोर्ट त्रुटि), तो फ्रेमवर्क "जहां आपने छोड़ा था वहां से जारी रखें" के ठीक बाद, रेज़्यूमे प्रॉम्प्ट में एक **संरचित जर्नल नोट** जोड़ता है। नोट सादे पाठ में मॉडल को बताता है:
+
+- कौन सा टूल कॉल करता है **पहले से ही पूरा हो चुका है** (संक्षिप्त परिणामों के साथ) इसलिए यह उनका पुन: उपयोग करता है और उन्हें दोबारा **नहीं** चलाता है, और
+- कौन से टूल कॉल **अज्ञात परिणाम से बाधित** थे, इसलिए यह सफलता या विफलता मानने से पहले स्थिति की पुष्टि करता है।
+
+जब जर्नल खाली होता है (बिना किसी टूल गतिविधि वाला टर्न, या साफ़ निरंतरता), तो कुछ भी अतिरिक्त नहीं जोड़ा जाता है और फिर से शुरू करने का व्यवहार बाइट-दर-बाइट वही होता है जो पहले था। नोट सर्वोत्तम प्रयास है: एक असफल बही-खाता कभी भी उस पुनर्प्राप्ति को अवरुद्ध नहीं करता है जो अन्यथा सफल होती।
+
+## परत 2: टूल-लेयर हार्ड-ब्लॉक {#hard-block}
+
+संकेत नोट सलाहकारी है - एक अच्छा व्यवहार करने वाला मॉडल इस पर ध्यान देता है, लेकिन एक मॉडल कोई गारंटी नहीं है। तो लूप इसे टूल लेयर पर भी लागू करता है।
+
+लूप को फिर से शुरू किए गए हिस्से में चलाने से पहले, यह जर्नल को एक बार स्नैपशॉट देता है (इस तार्किक मोड़ के केवल **पूर्व** हिस्सों को कैप्चर करता है)। जब मॉडल एक **राइट** टूल को दोबारा भेजता है जिसका टूल नाम **और इनपुट** एक पूर्ण जर्नल प्रविष्टि से मेल खाता है, तो लूप शॉर्ट-सर्किट होता है: यह कार्रवाई को निष्पादित करने के बजाय जर्नल किए गए परिणाम को लौटाता है, एक नोट के साथ कि कॉल पहले ही बाधित प्रयास में पूरी हो चुकी है और डुप्लिकेट साइड इफेक्ट से बचने के लिए इसे दोबारा नहीं चलाया गया था।
+
+मुख्य गुण:
+
+- **केवल लिखने के उपकरण।** केवल-पढ़ने के लिए (`readOnly` / GET) actions को कभी भी अवरुद्ध नहीं किया जाता है - पुनः पढ़ना सुरक्षित और निष्क्रिय है।
+- **सामग्री-संबोधित।** मिलान टूल नाम + इनपुट हस्ताक्षर पर है, इसलिए टर्न में एक अलग स्थान पर बैठकर फिर से शुरू की गई कॉल अभी भी मेल खाती है; एक *अलग*कॉल (अलग-अलग तर्क) को ताज़ा माना जाता है और सामान्य रूप से चलता है।
+- **एक बार उपभोग करें।** मिलान होने पर प्रत्येक पूर्ण प्रविष्टि का दावा किया जाता है, इसलिए एक ही मोड़ में दो वास्तविक-अलग-अलग समान ताजा कॉल एक जर्नल पूर्ण होने पर शॉर्ट-सर्किट नहीं होती हैं।
+- **ताजा कॉल अछूती।** पहली बार कॉल करने पर एक खाली जर्नल दिखता है; सामान्य रन के लिए कुछ भी नहीं बदलता।
+
+```an-callout
+{
+  "tone": "success",
+  "body": "Together the two layers mean an interrupted run that already had a real side effect resumes **without repeating it** — no duplicate emails, charges, or tickets — while genuinely new work still runs. Read-only actions are never blocked; re-reading is always safe."
+}
+```
+
+## संबंधित
+
+- [**Real-Time Sync**](/docs/real-time-collaboration) - कैसे टिकाऊ रन लेजर क्लाइंट तक स्ट्रीम होता है और पुनः कनेक्ट होने पर पुनः चलता है।
+- [**Actions**](/docs/actions) - `readOnly` अंक पुनः चलाने के लिए सुरक्षित के रूप में पढ़ता है; बाकी सभी चीजों को साइड-इफेक्टिंग माना जाता है।
+- [**In-Loop Processors**](/docs/processors) - एक और लूप-आंतरिक सख्त सीम।