📘 תיעוד 185

הגדרת הרשאות

שלוט באופן שבו הסוכן שלך משתמש בכלים באמצעות מצבי הרשאה, hooks, וכללי allow ו-deny הצהרתיים.

ה-Claude Agent SDK מספק בקרות הרשאה לניהול האופן שבו Claude משתמש בכלים. השתמש במצבי הרשאה וכללים כדי להגדיר מה מותר אוטומטית, וב-canUseTool callback כדי לטפל בכל השאר בזמן ריצה.

#איך הרשאות מוערכות

[!NOTE]

אם אתה טוען תוסף שמכיל mod, ראה איפה ההחלטות של mod משתלבות בין כללים ו-hooks.

כש-Claude מבקש כלי, Claude Code בודק את הקריאה בשלבים האלה. כל שלב יכול להחליט על הקריאה, לשלוח אותה ל-callback canUseTool שלך, או להעביר אותה הלאה:

1. Hooks

הרץ hooks. hook יכול לדחות את הקריאה לחלוטין או להעביר אותה הלאה. hook שמחזיר allow לא מדלג על כללי ה-deny וכללי ה-ask שלמטה, שמוערכים בלי קשר לתוצאת ה-hook.

hook מסוג PreToolUse שמחזיר allow גם לא יכול לאשר פקודת rm או rmdir שהיעד שלה מזוהה על ידי Claude Code כ-critical path, כמו rm -rf ~. לגבי מה שה-allow הזה עושה במצב plan, ראה אישורי Hook במצב plan.

2. כללי Deny

אם כלל deny מ-disallowed_tools או מ-קובץ הגדרות שה-SDK טוען תואם, הקריאה נדחית ו-canUseTool לא נקרא. הקריאה נדחית כך גם במצב bypassPermissions וגם כש-hook החזיר allow.

ב-TypeScript SDK, אם אתה מגדיר את permission_policy של כלי מותאם ל-always_deny, קריאה לכלי הזה נדחית בשלב הזה.

3. כללי Ask

בדוק כללי ask מ-settings.json. אם כלל ask תואם, הקריאה עוברת ל-canUseTool callback שלך לאישור, גם במצב bypassPermissions.

כלים שדורשים אינטראקציה עם המשתמש מתנהגים באותו אופן. AskUserQuestion וכלי MCP שהשרת שלהם מגדיר _meta["anthropic/requiresUserInteraction"] עוברים ל-callback, גם כשכלל allow תואם. במצב dontAsk שני המקרים נדחים במקום זאת, כי המצב הזה הופך כל בקשה לדחייה. ה-annotation של MCP דורש Claude Code v2.1.199 או חדש יותר.

כלי claude.ai connector שהארגון שלך הגדיר ל-ask גם יוצאים מהזרימה בשלב הזה. כל קריאה עוברת ל-callback, גם במצב bypassPermissions וגם כשכלל allow תואם. ה-callback מקבל את הסיבה Your organization requires approval for this tool. במצב dontAsk הקריאה נדחית במקום זאת, כי המצב הזה אף פעם לא מבקש אישור.

ב-TypeScript SDK, אם אתה מגדיר את permission_policy של כלי מותאם ל-always_ask, אף כלל allow לא מאשר את הקריאות שלו, גם לא רשומת allowedTools. במצב dontAsk Claude Code דוחה את הקריאות האלה, ובמצב auto, plan, או bypassPermissions הוא יכול לאשר אותן לפני שה-callback שלך רץ.

4. מצב הרשאה

החל את מצב ההרשאה הפעיל:

• במצב bypassPermissions, Claude Code מאשר כל קריאה שמגיעה לשלב הזה, אלא אם היא אחת מ-הפעולות שאף מצב לא מאשר אוטומטית. לגבי אילו מהפעולות האלה עוברות ל-callback canUseTool שלך, ראה מצב Bypass permissions.
• במצב acceptEdits, Claude Code מאשר את פעולות הקבצים שמפורטות תחת מצב Accept edits.
• במצב plan, חלק מהקריאות מגיעות ל-callback שלך, וכשמצב auto זמין, אחרות עוברות למסווג שלו במקום זאת. למידע נוסף, ראה מצב Plan.
• במצב default ו-dontAsk, הקריאה ממשיכה לכללי allow.
• למצב auto, ראה מצב Auto.

5. כללי Allow

בדוק כללי allow (מ-allowed_tools ומ-settings.json). אם כלל תואם, הכלי מאושר. קריאה שהכלי מאשר בעצמו נפתרת גם בשלב הזה, בלי צורך בכלל: לדוגמה קריאת קובץ בתוך ספריות העבודה שלך או פקודת Bash לקריאה בלבד.

מחיקות של critical path שמזוהות לא מאושרות על ידי כלל allow, ופקודות שמסומנות Dangerous rm operation not ruled out לא מאושרות על ידי כלל Bash או Bash(*). האם הן מגיעות אחר כך ל-callback שלך תלוי במצב ההרשאה: בסשן Agent SDK במצב auto, לדוגמה, Claude Code דוחה אותן כברירת מחדל בלי לקרוא לו. טבלת מצבי critical paths מפרטת מה כל מצב עושה איתן.

כלל allow לא מאשר קריאה מ-נתיב רשת.

6. canUseTool callback

אם לא נפתר על ידי אף אחד מהשלבים שלמעלה, קרא ל-canUseTool callback שלך להחלטה. במצב dontAsk, השלב הזה מדולג והכלי נדחה, אם כי mod שהתקנת עדיין יכול לאשר חלק מקריאות כאלה.

ב-TypeScript SDK, אם אתה מגדיר permissionPrompts: 'none', ה-callback שלך לא נקרא בשלב הזה. hook מסוג PermissionRequest עדיין מקבל הזדמנות להחליט, ואם הוא לא מחליט, Claude Code דוחה את הקריאה. האפשרות דורשת Claude Code v2.1.259 או חדש יותר.

אם אתה מעביר callback של canUseTool בתצורה שבה TypeScript SDK מצפה שסדר ההערכה יאשר קריאות אוטומטית לפני שה-callback נבדק, ה-SDK פולט אזהרת תהליך Node.js פעם אחת כשה-query נבנה. הקוד של האזהרה הוא CLAUDE_SDK_CAN_USE_TOOL_SHADOWED. שתי תצורות מפעילות אותה:

• permissionMode: 'bypassPermissions': טקסט האזהרה מתחיל ב-canUseTool will not be invoked: permissionMode 'bypassPermissions'. קריאות לכלים מאושרות לפני ש-canUseTool נבדק, כך שה-callback שלך רץ רק עבור כמה קריאות, כמו הקריאות שמפורטות תחת מצב Bypass permissions. כדי לבדוק גם את הקריאות המאושרות, שים את הבדיקות של ה-callback שלך ב-hook מסוג PreToolUse
• רשומת allowedTools שהיא רק שם כלי, כמו "Read": האזהרה מפרטת כל רשומה כזאת אחרי canUseTool will not be invoked for:. קריאות לכלי שברשימה מאושרות לפני ש-canUseTool נבדק, מלבד הקריאות שכלל allow אף פעם לא מאשר. כדי שה-callback שלך ירוץ עבור קריאות של כלי ברשימה שצריכות אישור, הסר את הרשומה של הכלי הזה מ-allowedTools

רשומות עם מפרט כמו Bash(ls *) ומצב acceptEdits לא מפעילות אותה, וכללי allow שמגיעים מקובצי הגדרות לא גלויים לבדיקה.

האזהרה לא חוסמת שום קריאה ולא משנה שום אפשרות. אם ה-callback שלך כבר מקבל כל קריאה שאתה רוצה לבדוק, השאר את התצורה כמו שהיא. כדי לרשום את האזהרה בלוג, האזן עם process.on('warning', ...) והתאם לקוד CLAUDE_SDK_CAN_USE_TOOL_SHADOWED.

הדף הזה מתמקד בכללי allow ו-deny ובמצבי הרשאה. לשלבים האחרים:

• Hooks: הרץ קוד מותאם כדי לאפשר, לדחות, או לשנות בקשות לכלים. ראה שליטה בביצוע עם hooks.
• canUseTool callback: בקש מהמשתמשים אישור בזמן ריצה, כשאף שלב קודם לא פותר את הקריאה. ראה טיפול באישורים ובקלט משתמש.

#כללי allow ו-deny

allowed_tools ו-disallowed_tools (TypeScript: allowedTools / disallowedTools) מוסיפים רשומות לרשימות כללי ה-allow וה-deny בזרימת ההערכה שלמעלה. אם תנקוב בשם של אחד מכלי מעקב המשימות ב-allowed_tools, Claude Code גם מבצע opt-in של הסשן. כל כלי אחר שלא רשום ב-allowed_tools עדיין זמין ל-Claude, וקריאה אליו שדורשת אישור עוברת אל מצב ההרשאות. כללי deny מתנהגים אחרת לפי זה אם הם נוקבים בשם של כלי, או תוחמים תבנית בתוך כלי אחד.

כללי allow מקבלים glob של שם כלי רק אחרי קידומת מילולית mcp__<server>__. מקטע השרת חייב להיות בלי glob, כדי שהכלל ינקוב בשרת מסוים שהגדרת: mcp__puppeteer__* תואם כל כלי משרת puppeteer, ו-mcp__github__get_* תואם את כלי ה-get_ שלו. רשומה לא מעוגנת כמו allowed_tools=["*"] או allowed_tools=["mcp__*"] מתעלמים ממנה, והיא לא מאשרת שום דבר אוטומטית.

[!WARNING]

כלים שאושרו אוטומטית אף פעם לא מגיעים אל canUseTool. קריאת כלי שאושרה בשלב מוקדם יותר, על ידי acceptEdits או bypassPermissions, או על ידי כלל allow, מדלגת על ה-callback של canUseTool, ולכן בדיקות הרשאה ששמת שם נעקפות בשקט עבור הכלי הזה.

אם קריאות לכלי ב-allowed_tools עדיין מגיעות ל-callback של canUseTool, או נדחות במצב dontAsk, בדוק אם הן קריאות מנתיבי רשת או בין הקריאות הבאות. אף כלל allow לא מאשר את הקריאות האלה. במצב dontAsk, שלא מציג בקשות אף פעם, Claude Code דוחה אותן בלי לקרוא ל-canUseTool, ובמצבי ההרשאות האחרים אתה מטפל בהן כפי שכל פריט אומר:

• AskUserQuestion, כלי MCP שמסומנים _meta["anthropic/requiresUserInteraction"], וכלי connector שהארגון שלך הגדיר ל-ask: ענה עליהן ב-callback. טיפול בשאלות הבהרה מראה איך לענות ל-AskUserQuestion, וקריאה ל-connector מגיעה עם הסיבה Your organization requires approval for this tool

• כלים מותאמים שהאפליקציה שלך מסמנת always_ask: החלט על הקריאה ב-callback. כדי לעצור את ההגעה של הקריאות האלה, שנה את המדיניות באמצע הסשן. במצבים auto, plan ו-bypassPermissions הקריאה יכולה במקום זאת להיות מאושרת לפני ה-callback, במקרים שרשומים תחת מצבי הרשאה שיכולים לאשר קריאה מסוג always_ask

• מחיקות מוכרות של rm ו-rmdir בנתיבים קריטיים: במצבים default, acceptEdits ו-bypassPermissions, אשר או דחה את המחיקה ב-callback, כאשר decisionReason מתחיל ב-Dangerous rm. למצבים auto ו-plan, ראה מחיקות של נתיבים קריטיים בכל מצב הרשאה

• שם חשוף: רשומה כמו Read או mcp__github__get_issue מאשרת אוטומטית כל קריאה לכלי הזה, מלבד הפעולות שאף מצב לא מאשר אוטומטית וקריאות מנתיבי רשת.

• כלל ממוקד: רשומה כמו Bash(npm test *) מאשרת אוטומטית קריאות שתואמות אותה, וקריאות Bash אחרות שדורשות אישור עוברות אל מצב ההרשאות.

כדי לבדוק קריאות שכלל allow, acceptEdits או bypassPermissions מאשר, השתמש ב-hook מסוג PreToolUse, שרץ גם עבור הקריאות האלה. דחייה של hook חלה גם במצב bypassPermissions.

עבור סוכן נעול, צמד את allowedTools עם permissionMode: "dontAsk":

const options = {
  allowedTools: ["Read", "Glob", "Grep"],
  permissionMode: "dontAsk"
};

הקריאות הרשומות ל-Read, ל-Glob ול-Grep מאושרות, מלבד הפעולות שאף מצב לא מאשר אוטומטית וקריאות מנתיבי רשת. כל קריאה אחרת שהייתה מציגה בקשה נדחית במקום זאת, אם כי מוד שהתקנת עדיין יכול לאשר חלק מהקריאות האלה.

קריאות שלא זקוקות לאישור במצב default רצות בין אם רשמת אותן ובין אם לא. אלה כוללות פקודות Bash לקריאה בלבד, כלים כמו Agent שלא שואלים לפני הרצה, וקריאות קבצים בתוך ספריות העבודה שלך. כדי להסתיר כלי מובנה מ-Claude לגמרי במקום לדחות את הקריאות שלו, הוסף את השם החשוף שלו ל-disallowedTools.

[!WARNING]

allowed_tools לא מגביל את bypassPermissions. allowed_tools מאשר מראש את הכלים שאתה רושם. במצב bypassPermissions, Claude Code מאשר קריאה לכלי שלא רשום, אלא אם היא אחת מהפעולות שאף מצב לא מאשר אוטומטית.

אם תגדיר allowed_tools=["Read"] עם permission_mode="bypassPermissions", Claude Code עדיין מאשר קריאות לכלים כמו Bash, Write ו-Edit. אם אתה צריך את bypassPermissions אבל רוצה לחסום כלים מסוימים, השתמש ב-disallowed_tools. לקריאות שעדיין מגיעות ל-callback של canUseTool במצב הזה, ראה מצב עקיפת הרשאות.

אפשר גם להגדיר כללי allow, deny ו-ask באופן דקלרטיבי ב-.claude/settings.json. הכללים האלה נקראים כשמקור ההגדרה project מופעל, וזה המצב באפשרויות ברירת המחדל של query(). אם תגדיר את setting_sources (TypeScript: settingSources) במפורש, כלול את "project" כדי שהן יחולו. ראה הגדרות הרשאות לתחביר הכללים.

לגבי מתי כללי allow בקובץ .claude/settings.json של פרויקט חלים, ראה כללי allow של הפרויקט ואמון ב-workspace.

#תבניות נתיב בכללים

כללים ממוקדים עבור Read ו-Edit מקבלים תבנית נתיב. כללי Edit(path) חלים על כל הכלים המובנים שכותבים קבצים, כולל Write ו-NotebookEdit, ולכן כתוב כלל נתיב לכל אחד מהם כ-Edit(path). אם תכתוב כלל נתיב כ-Write(path) או NotebookEdit(path), הוא לא תואם אף קריאה ואין לו השפעה.

ב-allowed_tools וב-disallowed_tools, התחל תבנית נתיב ב-// לנתיב מוחלט, או ב-/ אחד לנתיב בתוך ספריית העבודה של הסשן:

• //path: עם כלל deny של Edit(//secrets/**), Claude Code חוסם כתיבות מתחת ל-/secrets בדיסק מכלי הקבצים של Claude ומפקודות Bash כמו tee והפניית > file. סקריפט ש-Claude מריץ ושפותח קבצים בעצמו עדיין יכול לכתוב מתחת ל-/secrets. לאכיפה על ידי מערכת ההפעלה, ראה הגדרת כלי Bash בארגז חול.
• /path: Edit(/secrets/**) תואם את ספריית secrets בתוך ספריית העבודה.

לדרכים אחרות להתחיל תבנית נתיב, ראה כללי Read ו-Edit.

#מצבי הרשאה

מצבי הרשאה נותנים שליטה גלובלית על האופן שבו Claude משתמש בכלים. אפשר להגדיר את מצב ההרשאה בקריאה ל-query(), או לשנות אותו באופן דינמי במהלך סשני הזרמה.

ב-Claude Code מגרסה v2.1.302 ואילך, האפליקציה מתחילה במצב default אלא אם הגדרת מצב הרשאה, או שהיא מקבלת מצב מ-permissions.defaultMode בקבצי ההגדרות שלה. במצב default, Claude Code דוחה כל קריאת כלי שדורשת אישור, אלא אם מאשרים אותה דרך כלל allow, hook, קולבק canUseTool, או כלי בקשת הרשאה. אם קריאות כלים נדחות, ראה קריאות כלים שנדחות בהרצות claude -p וב-Agent SDK.

#מצבים זמינים

ה-SDK תומך במצבי ההרשאה האלה:

[!WARNING]

הורשת סוכן משנה: אם הסשן הראשי נמצא במצב plan, סוכן משנה ש-AgentDefinition שלו מגדיר permissionMode: "acceptEdits" עדיין רץ במצב plan. קריאות Edit ו-Write של סוכן המשנה הזה על קובצי המקור שלך עדיין מגיעות לקולבק canUseTool. מצב plan חל גם על סוכני המשנה שאתה מגדיר, כדי שמסירת עבודה לאחד מהם לא תעקוף את הבדיקה של התוכנית קודם.

סוכן המשנה יורש plan, acceptEdits, auto או bypassPermissions מהסשן הראשי, ותחת סשן ראשי במצב default או dontAsk הוא רץ במצב שהגדרת. גם אז, Claude Code אף פעם לא מחיל ערך "bypassPermissions", ומחיל ערך "auto" רק כשמצב auto זמין לסוכן המשנה הזה. החריג של bypassPermissions דורש Claude Code מגרסה v2.1.267 ואילך.

לסוכני משנה עשויים להיות system prompt שונים והתנהגות פחות מוגבלת מהסוכן הראשי, ולכן הורשת bypassPermissions מעניקה להם גישת מערכת מלאה ואוטונומית. הפעולות שאף מצב לא מאשר אוטומטית עדיין חלות.

#הגדרת מצב הרשאה

אפשר להגדיר את מצב ההרשאה פעם אחת בתחילת שאילתה, או לשנות אותו באופן דינמי בזמן שהסשן פעיל.

בזמן השאילתה

העבר את permission_mode (Python) או permissionMode (TypeScript) ביצירת שאילתה.

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions


async def main():
    async for message in query(
        prompt="Help me refactor this code",
        options=ClaudeAgentOptions(
            permission_mode="default",  # Set the mode here
        ),
    ):
        if hasattr(message, "result"):
            print(message.result)


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";

async function main() {
  for await (const message of query({
    prompt: "Help me refactor this code",
    options: {
      permissionMode: "default" // Set the mode here
    }
  })) {
    if ("result" in message) {
      console.log(message.result);
    }
  }
}

main();

במהלך הזרמה

קרא ל-set_permission_mode() (Python) או ל-setPermissionMode() (TypeScript) כדי לשנות את המצב באמצע הסשן. המצב החדש נכנס לתוקף מיד לכל בקשות הכלים הבאות. זה מאפשר להתחיל בהגבלה ולשחרר הרשאות ככל שהאמון גדל, למשל מעבר ל-acceptEdits אחרי בדיקת הגישה הראשונית של Claude.

import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions


async def main():
    async with ClaudeSDKClient(
        options=ClaudeAgentOptions(
            permission_mode="default",  # Start in default mode
        )
    ) as client:
        await client.query("Help me refactor this code")

        # Change mode dynamically mid-session
        await client.set_permission_mode("acceptEdits")

        # Process messages with the new permission mode
        async for message in client.receive_response():
            if hasattr(message, "result"):
                print(message.result)


asyncio.run(main())

import { query } from "@anthropic-ai/claude-agent-sdk";

async function main() {
  const q = query({
    prompt: "Help me refactor this code",
    options: {
      permissionMode: "default" // Start in default mode
    }
  });

  // Change mode dynamically mid-session
  await q.setPermissionMode("acceptEdits");

  // Process messages with the new permission mode
  for await (const message of q) {
    if ("result" in message) {
      console.log(message.result);
    }
  }
}

main();

#פרטי מצבים

#מצב קבלת עריכות (acceptEdits)

מאשר אוטומטית פעולות קבצים כדי ש-Claude יוכל לערוך קוד בלי בקשת אישור. כלים אחרים (כמו פקודות Bash שאינן פעולות מערכת קבצים) עדיין דורשים הרשאות רגילות.

פעולות שמאושרות אוטומטית:

• עריכות קבצים עם הכלים Edit, Write ו-NotebookEdit
• פקודות מערכת קבצים: mkdir, touch, rm, rmdir, mv, cp, sed

שניהם חלים על נתיבים בתוך ספריית העבודה או ספרייה שמוסיפים. ב-Python מוסיפים אחת עם add_dirs, וב-TypeScript עם additionalDirectories. במצב acceptEdits, Claude Code לא מאשר אוטומטית את הבקשה כש-Claude:

• עובד על נתיב מחוץ להיקף הזה
• כותב לנתיב מוגן
• מסיר נתיב ש-Claude Code מזהה כנתיב קריטי עם rm או rmdir
• מריץ touch עם, למשל, אפשרות, glob, או קידומת timeout 5 או LANG=C

מתי להשתמש: כשסומכים על העריכות של Claude ורוצים איטרציה מהירה יותר, למשל במהלך אב טיפוס או בעבודה בספרייה מבודדת.

#מצב בלי שאלות (dontAsk)

הופך כל בקשת הרשאה לדחייה, בלי קריאה ל-canUseTool, אם כי mod שהתקנת עדיין יכול לאשר חלק מהקריאות האלה. כלים שאושרו מראש על ידי allowed_tools, כללי allow ב-settings.json, או hook רצים כרגיל. קריאות שאינן דורשות אישור במצב default גם רצות כרגיל, כמו קריאות קבצים בתוך ספריות העבודה וקריאות ל-Agent.

הקריאות האלה נדחות גם כשכלל allow תואם:

• כלי connector שהארגון הגדיר ל-ask
• כלים שדורשים אינטראקציה עם המשתמש, כמו AskUserQuestion וכלי MCP שהשרת שלהם מגדיר _meta["anthropic/requiresUserInteraction"]
• כלים מותאמים שהאפליקציה מגדירה את permission_policy שלהם ל-always_ask
• קריאות מנתיבי רשת
• הסרות נתיב קריטי מזוהות

אם hook מסוג PreToolUse מחזיר allow להסרת נתיב קריטי מזוהה, לקריאה מנתיב רשת, או לקריאה לכלי שמסומן always_ask, הקריאה עדיין נדחית. הבדיקה שמזהה את ההסרות האלה עלולה לפספס חלק מהפקודות.

מתי להשתמש: כשמריצים סוכן headless ורוצים דחייה קשיחה לכל קריאה שהייתה מבקשת אישור.

#מצב עקיפת הרשאות (bypassPermissions)

מאשר אוטומטית שימושים בכלים בלי בקשת אישור, למעט הפעולות שאף מצב לא מאשר אוטומטית. hooks עדיין רצים ויכולים לחסום פעולות לפי הצורך. ב-Linux וב-macOS, Claude Code מסרב להתחיל במצב הזה כ-root או תחת sudo מחוץ לsandbox מזוהה, והשאילתה נכשלת לפני התור הראשון.

[!WARNING]

יש להשתמש בזהירות רבה. ל-Claude יש גישת מערכת מלאה במצב הזה. יש להשתמש רק בסביבות מבוקרות שבהן סומכים על כל הפעולות האפשריות.

allowed_tools לא מגביל את המצב הזה, וגם קריאות לכלים שלא רשמת מאושרות. הבקרות האלה עדיין חלות:

• כללי deny, כללי ask מפורשים ו-hooks נבדקים לפני בדיקת המצב, ועדיין יכולים לחסום כלי.
• כלי connector שהארגון הגדיר ל-ask, כלים שדורשים אינטראקציה עם המשתמש, הסרות נתיב קריטי מזוהות, ופקודות Bash שסומנו Dangerous rm operation not ruled out עדיין עוברות לקולבק canUseTool. הבדיקה שמזהה הסרות נתיב קריטי עלולה לפספס חלק מהפקודות, ואפשר לכבות את בקשת ההסרה של נתיב קריטי. מחוץ לסשן ענן, גם קריאות לכלים מותאמים שהאפליקציה מסמנת always_ask עוברות לקולבק.
• ההגנות על הודעות בין סשנים עדיין חלות.

#מצב תכנון (plan)

Claude חוקר את בסיס הקוד ומייצר תוכנית. במהלך התכנון, עריכות שנעשות עם כלי הקבצים של Claude מחוץ לנתיבים מוגנים מגיעות לקולבק canUseTool, גם כשכלל allow תואם או כש-hook מסוג PreToolUse מחזיר allow. גם קריאות AskUserQuestion מגיעות לקולבק, גם כשכלל allow מציין את הכלי.

כשמצב auto זמין, Claude Code שולח את הקריאות האלה במהלך התכנון למסווג של מצב auto לבדיקה, במקום לקולבק, כשאף כלל allow לא מאשר אותן:

• פקודות מעטפת
• אחזורי אינטרנט
• חיפושי אינטרנט
• קריאות לכלי MCP שהשרת שלהם מסמן לקריאה בלבד

הבדיקה הזו פעילה כברירת מחדל. כדי לכבות אותה, הגדר את useAutoModeDuringPlan ל-false באפשרות settings שמעבירים ל-query(), או בהגדרות המשתמש. כשהבדיקה כבויה, חיפושי אינטרנט וקריאות לכלי MCP שמסומנים לקריאה בלבד מגיעים לקולבק.

לפקודות מעטפת ולאחזורי אינטרנט, הטבלה מראה אם כל קריאה מגיעה לקולבק:

למה שקורה אחרי שהמסווג דוחה כמה קריאות ברצף, ראה ספי חסימה חוזרת.

[!NOTE]

ב-SDK של TypeScript, אם מגדירים allowDangerouslySkipPermissions: true יחד עם permissionMode: 'plan', עריכות קבצים עדיין מגיעות לקולבק canUseTool. כדי להעביר בהמשך סשן שמתחיל במצב plan ל-bypassPermissions באמצעות setPermissionMode(), צריך ש-allowDangerouslySkipPermissions יהיה מוגדר מההתחלה.

מתי להשתמש: כשרוצים ש-Claude ייצר תוכנית קודם, למשל במהלך סקירת קוד או לפני שינוי גדול.

#מצב Auto (auto)

מודל מסווג בודק פעולות כמו פקודות מעטפת ובקשות רשת לפני שהן רצות, ומאפשר או חוסם כל אחת שהוא בודק. למודלים ולספקים שמצב auto דורש, ולסדר שבו הוא מעריך פעולות, ראה ביטול בקשות הרשאה עם מצב auto.

אם מעבירים סשן שנמצא במצב auto למודל שמצב auto לא תומך בו, באמצעות set_model(), setModel() או applyFlagSettings(), הסשן עובר למצב default:

• מה רואים: הודעת system עם subtype status ו-permissionMode שמוגדר ל-"default", שה-SDK של TypeScript מטייפ כ-SDKStatusMessage. מכאן והלאה, קריאות שדורשות אישור ואינן תואמות לאף כלל allow מגיעות לקולבק canUseTool.
• כדי לחזור למצב auto: עבור למודל נתמך, ואז קרא ל-set_permission_mode("auto") או ל-setPermissionMode("auto"). אם מחזירים את המודל בלי לבצע את הקריאה הזו, הסשן נשאר במצב default. כל עוד המודל שאינו נתמך פעיל, הקריאה נכשלת עם Cannot set permission mode to auto: auto mode unavailable for this model.

המעבר למצב default אחרי קריאה ל-set_model(), setModel() או applyFlagSettings() דורש Claude Code מגרסה v2.1.299 ואילך.

#משאבים קשורים

לשלבים האחרים בזרימת הערכת ההרשאות:

• טיפול באישורים ובקלט משתמש: בקשות אישור אינטראקטיביות ושאלות הבהרה
• מדריך hooks: הרצת קוד מותאם בנקודות מפתח במחזור החיים של הסוכן
• כללי הרשאה: כללי allow/deny הצהרתיים ב-settings.json