"""
Workflow exception messages for internationalization
Contains all messages used by workflow exceptions and loader validation
"""

WORKFLOW_EXCEPTION_MESSAGES = {
    # ========== Loader Validation Messages ==========
    # YAML file validation
    "workflow.yaml_empty": {
        "en": "YAML file is empty or contains only comments",
        "zh": "YAML 文件为空或仅包含注释",
        "ja": "YAML ファイルが空またはコメントのみです",
        "ar": "ملف YAML فارغ أو يحتوي على تعليقات فقط",
        "ru": "Файл YAML пуст или содержит только комментарии",
    },
    "workflow.yaml_empty_suggestion": {
        "en": "Please ensure YAML file contains valid workflow configuration",
        "zh": "请确保 YAML 文件包含有效的 workflow 配置",
        "ja": "YAML ファイルに有効な workflow 設定が含まれていることを確認してください",
        "ar": "يرجى التأكد من أن ملف YAML يحتوي على تكوين workflow صالح",
        "ru": "Убедитесь, что файл YAML содержит действительную конфигурацию workflow",
    },
    # apiVersion validation
    "workflow.unsupported_api_version": {
        "en": "Unsupported apiVersion",
        "zh": "不支持的 apiVersion",
        "ja": "サポートされていない apiVersion",
        "ar": "apiVersion غير مدعوم",
        "ru": "Неподдерживаемая apiVersion",
    },
    "workflow.api_version_suggestion": {
        "en": "Please change apiVersion to 'autocoder/v1'",
        "zh": "请将 apiVersion 修改为 'autocoder/v1'",
        "ja": "apiVersion を 'autocoder/v1' に変更してください",
        "ar": "يرجى تغيير apiVersion إلى 'autocoder/v1'",
        "ru": "Измените apiVersion на 'autocoder/v1'",
    },
    # kind validation
    "workflow.unsupported_kind": {
        "en": "Unsupported kind",
        "zh": "不支持的 kind",
        "ja": "サポートされていない kind",
        "ar": "kind غير مدعوم",
        "ru": "Неподдерживаемый kind",
    },
    "workflow.kind_suggestion": {
        "en": "Please change kind to 'SubagentWorkflow'",
        "zh": "请将 kind 修改为 'SubagentWorkflow'",
        "ja": "kind を 'SubagentWorkflow' に変更してください",
        "ar": "يرجى تغيير kind إلى 'SubagentWorkflow'",
        "ru": "Измените kind на 'SubagentWorkflow'",
    },
    # metadata.name validation
    "workflow.metadata_name_empty": {
        "en": "metadata.name cannot be empty",
        "zh": "metadata.name 不能为空",
        "ja": "metadata.name は空にできません",
        "ar": "metadata.name لا يمكن أن يكون فارغاً",
        "ru": "metadata.name не может быть пустым",
    },
    "workflow.metadata_name_suggestion": {
        "en": "Please set a meaningful workflow name, e.g., 'my-workflow'",
        "zh": "请设置一个有意义的 workflow 名称，如 'my-workflow'",
        "ja": "意味のある workflow 名を設定してください。例: 'my-workflow'",
        "ar": "يرجى تعيين اسم workflow ذي معنى، مثل 'my-workflow'",
        "ru": "Задайте осмысленное имя workflow, например 'my-workflow'",
    },
    # spec validation
    "workflow.spec_must_be_dict": {
        "en": "spec must be a dictionary object",
        "zh": "spec 必须是一个字典对象",
        "ja": "spec は辞書オブジェクトでなければなりません",
        "ar": "spec يجب أن يكون كائن قاموس",
        "ru": "spec должен быть объектом-словарем",
    },
    "workflow.spec_dict_suggestion": {
        "en": "Please ensure spec: is followed by dictionary format configuration",
        "zh": "请确保 spec: 后面跟的是字典格式的配置",
        "ja": "spec: の後に辞書形式の設定が続くことを確認してください",
        "ar": "تأكد من أن spec: متبوع بتنسيق قاموس",
        "ru": "Убедитесь, что после spec: следует конфигурация в формате словаря",
    },
    # vars validation
    "workflow.vars_must_be_dict": {
        "en": "spec.vars must be a dictionary object",
        "zh": "spec.vars 必须是字典对象",
        "ja": "spec.vars は辞書オブジェクトでなければなりません",
        "ar": "spec.vars يجب أن يكون كائن قاموس",
        "ru": "spec.vars должен быть объектом-словарем",
    },
    "workflow.vars_dict_suggestion": {
        "en": "Define vars as key-value pairs, e.g., vars:\\n  project_type: '*'",
        "zh": "将 vars 定义为键值对，如: vars:\\n  project_type: '*'",
        "ja": "vars をキー値ペアとして定義してください。例: vars:\\n  project_type: '*'",
        "ar": "عرّف vars كأزواج مفتاح-قيمة، مثل: vars:\\n  project_type: '*'",
        "ru": "Определите vars как пары ключ-значение, например: vars:\\n  project_type: '*'",
    },
    # agents validation
    "workflow.agents_must_be_list": {
        "en": "spec.agents must be a list",
        "zh": "spec.agents 必须是列表",
        "ja": "spec.agents はリストでなければなりません",
        "ar": "spec.agents يجب أن يكون قائمة",
        "ru": "spec.agents должен быть списком",
    },
    "workflow.agents_list_suggestion": {
        "en": "Ensure agents: is followed by list format, each item starts with -",
        "zh": "确保 agents: 后面跟的是列表格式，每项以 - 开头",
        "ja": "agents: の後にリスト形式が続き、各項目が - で始まることを確認してください",
        "ar": "تأكد من أن agents: متبوع بتنسيق قائمة، كل عنصر يبدأ بـ -",
        "ru": "Убедитесь, что после agents: следует формат списка, каждый элемент начинается с -",
    },
    "workflow.agents_empty": {
        "en": "spec.agents cannot be empty",
        "zh": "spec.agents 不能为空",
        "ja": "spec.agents は空にできません",
        "ar": "spec.agents لا يمكن أن يكون فارغاً",
        "ru": "spec.agents не может быть пустым",
    },
    "workflow.agents_empty_suggestion": {
        "en": "Please define at least one agent, e.g.:\\n  - id: context\\n    path: context.md",
        "zh": "请定义至少一个 agent，例如:\\n  - id: context\\n    path: context.md",
        "ja": "少なくとも1つのエージェントを定義してください。例:\\n  - id: context\\n    path: context.md",
        "ar": "يرجى تعريف وكيل واحد على الأقل، مثال:\\n  - id: context\\n    path: context.md",
        "ru": "Определите хотя бы одного агента, например:\\n  - id: context\\n    path: context.md",
    },
    "workflow.duplicate_agent_ids": {
        "en": "Duplicate agent IDs found: {{ids}}",
        "zh": "发现重复的 agent ID: {{ids}}",
        "ja": "重複したエージェント ID が見つかりました: {{ids}}",
        "ar": "تم العثور على معرفات وكيل مكررة: {{ids}}",
        "ru": "Обнаружены повторяющиеся ID агентов: {{ids}}",
    },
    "workflow.duplicate_agent_ids_suggestion": {
        "en": "Each agent's id must be unique, please modify the duplicate IDs",
        "zh": "每个 agent 的 id 必须唯一，请修改重复的 ID",
        "ja": "各エージェントの id は一意でなければなりません。重複した ID を修正してください",
        "ar": "يجب أن يكون معرف كل وكيل فريداً، يرجى تعديل المعرفات المكررة",
        "ru": "Каждый id агента должен быть уникальным, исправьте повторяющиеся ID",
    },
    # steps validation
    "workflow.steps_must_be_list": {
        "en": "spec.steps must be a list",
        "zh": "spec.steps 必须是列表",
        "ja": "spec.steps はリストでなければなりません",
        "ar": "spec.steps يجب أن يكون قائمة",
        "ru": "spec.steps должен быть списком",
    },
    "workflow.steps_list_suggestion": {
        "en": "Ensure steps: is followed by list format, each item starts with -",
        "zh": "确保 steps: 后面跟的是列表格式，每项以 - 开头",
        "ja": "steps: の後にリスト形式が続き、各項目が - で始まることを確認してください",
        "ar": "تأكد من أن steps: متبوع بتنسيق قائمة، كل عنصر يبدأ بـ -",
        "ru": "Убедитесь, что после steps: следует формат списка, каждый элемент начинается с -",
    },
    "workflow.steps_empty": {
        "en": "spec.steps cannot be empty",
        "zh": "spec.steps 不能为空",
        "ja": "spec.steps は空にできません",
        "ar": "spec.steps لا يمكن أن يكون فارغاً",
        "ru": "spec.steps не может быть пустым",
    },
    "workflow.steps_empty_suggestion": {
        "en": "Please define at least one step, e.g.:\\n  - id: step1\\n    agent: context",
        "zh": "请定义至少一个 step，例如:\\n  - id: step1\\n    agent: context",
        "ja": "少なくとも1つのステップを定義してください。例:\\n  - id: step1\\n    agent: context",
        "ar": "يرجى تعريف خطوة واحدة على الأقل، مثال:\\n  - id: step1\\n    agent: context",
        "ru": "Определите хотя бы один шаг, например:\\n  - id: step1\\n    agent: context",
    },
    "workflow.duplicate_step_ids": {
        "en": "Duplicate step IDs found: {{ids}}",
        "zh": "发现重复的 step ID: {{ids}}",
        "ja": "重複したステップ ID が見つかりました: {{ids}}",
        "ar": "تم العثور على معرفات خطوة مكررة: {{ids}}",
        "ru": "Обнаружены повторяющиеся ID шагов: {{ids}}",
    },
    "workflow.duplicate_step_ids_suggestion": {
        "en": "Each step's id must be unique, please modify the duplicate IDs",
        "zh": "每个 step 的 id 必须唯一，请修改重复的 ID",
        "ja": "各ステップの id は一意でなければなりません。重複した ID を修正してください",
        "ar": "يجب أن يكون معرف كل خطوة فريداً، يرجى تعديل المعرفات المكررة",
        "ru": "Каждый id шага должен быть уникальным, исправьте повторяющиеся ID",
    },
    # agent spec validation
    "workflow.invalid_runner_type": {
        "en": "Invalid agent runner type",
        "zh": "agent runner 类型无效",
        "ja": "無効なエージェント runner タイプ",
        "ar": "نوع runner الوكيل غير صالح",
        "ru": "Недопустимый тип runner агента",
    },
    "workflow.runner_type_suggestion": {
        "en": "runner value must be 'sdk' or 'terminal'",
        "zh": "runner 值必须是 'sdk' 或 'terminal'",
        "ja": "runner 値は 'sdk' または 'terminal' でなければなりません",
        "ar": "قيمة runner يجب أن تكون 'sdk' أو 'terminal'",
        "ru": "Значение runner должно быть 'sdk' или 'terminal'",
    },
    # step spec validation
    "workflow.step_agent_not_found": {
        "en": "Step references non-existent agent: '{{agent_id}}'",
        "zh": "步骤引用的 agent 不存在: '{{agent_id}}'",
        "ja": "ステップが存在しないエージェントを参照しています: '{{agent_id}}'",
        "ar": "الخطوة تشير إلى وكيل غير موجود: '{{agent_id}}'",
        "ru": "Шаг ссылается на несуществующего агента: '{{agent_id}}'",
    },
    "workflow.step_agent_suggestion": {
        "en": "Please change agent to a defined agent ID, or add '{{agent_id}}' definition in spec.agents",
        "zh": "请将 agent 修改为已定义的 agent ID，或在 spec.agents 中添加 '{{agent_id}}' 的定义",
        "ja": "agent を定義済みのエージェント ID に変更するか、spec.agents に '{{agent_id}}' の定義を追加してください",
        "ar": "يرجى تغيير agent إلى معرف وكيل معرّف، أو إضافة تعريف '{{agent_id}}' في spec.agents",
        "ru": "Измените agent на определенный ID агента или добавьте определение '{{agent_id}}' в spec.agents",
    },
    "workflow.needs_must_be_list": {
        "en": "needs must be a list",
        "zh": "needs 必须是列表",
        "ja": "needs はリストでなければなりません",
        "ar": "needs يجب أن يكون قائمة",
        "ru": "needs должен быть списком",
    },
    "workflow.needs_list_suggestion": {
        "en": "Define needs as a list, e.g., needs: [step1, step2]",
        "zh": "将 needs 定义为列表，如: needs: [step1, step2]",
        "ja": "needs をリストとして定義してください。例: needs: [step1, step2]",
        "ar": "عرّف needs كقائمة، مثل: needs: [step1, step2]",
        "ru": "Определите needs как список, например: needs: [step1, step2]",
    },
    "workflow.outputs_must_be_dict": {
        "en": "outputs must be a dictionary object",
        "zh": "outputs 必须是字典对象",
        "ja": "outputs は辞書オブジェクトでなければなりません",
        "ar": "outputs يجب أن يكون كائن قاموس",
        "ru": "outputs должен быть объектом-словарем",
    },
    "workflow.outputs_dict_suggestion": {
        "en": "Define outputs as key-value pairs",
        "zh": "将 outputs 定义为键值对",
        "ja": "outputs をキー値ペアとして定義してください",
        "ar": "عرّف outputs كأزواج مفتاح-قيمة",
        "ru": "Определите outputs как пары ключ-значение",
    },
    "workflow.replicas_must_be_positive": {
        "en": "replicas must be a positive integer",
        "zh": "replicas 必须是正整数",
        "ja": "replicas は正の整数でなければなりません",
        "ar": "replicas يجب أن يكون عدداً صحيحاً موجباً",
        "ru": "replicas должен быть положительным целым числом",
    },
    "workflow.replicas_suggestion": {
        "en": "Set replicas to a positive integer, e.g., 2 (run 2 replicas in parallel)",
        "zh": "将 replicas 设置为正整数，如 2（表示并行运行2个副本）",
        "ja": "replicas を正の整数に設定してください。例: 2（2つのレプリカを並列実行）",
        "ar": "عيّن replicas كعدد صحيح موجب، مثل 2 (تشغيل نسختين بالتوازي)",
        "ru": "Установите replicas как положительное целое число, например 2 (запуск 2 реплик параллельно)",
    },
    # merge config validation
    "workflow.merge_must_be_dict": {
        "en": "merge must be a dictionary object",
        "zh": "merge 必须是字典对象",
        "ja": "merge は辞書オブジェクトでなければなりません",
        "ar": "merge يجب أن يكون كائن قاموس",
        "ru": "merge должен быть объектом-словарем",
    },
    "workflow.merge_dict_suggestion": {
        "en": "Please use dictionary format to define merge config, e.g., merge: { when: { ... } }",
        "zh": "请使用字典格式定义 merge 配置，如: merge: { when: { ... } }",
        "ja": "辞書形式で merge 設定を定義してください。例: merge: { when: { ... } }",
        "ar": "يرجى استخدام تنسيق القاموس لتعريف merge، مثل: merge: { when: { ... } }",
        "ru": "Используйте формат словаря для определения merge, например: merge: { when: { ... } }",
    },
    "workflow.merge_when_must_be_dict": {
        "en": "merge.when must be a dictionary object",
        "zh": "merge.when 必须是字典对象",
        "ja": "merge.when は辞書オブジェクトでなければなりません",
        "ar": "merge.when يجب أن يكون كائن قاموس",
        "ru": "merge.when должен быть объектом-словарем",
    },
    "workflow.merge_when_dict_suggestion": {
        "en": "Please use dictionary format to define when condition",
        "zh": "请使用字典格式定义 when 条件",
        "ja": "辞書形式で when 条件を定義してください",
        "ar": "يرجى استخدام تنسيق القاموس لتعريف شرط when",
        "ru": "Используйте формат словаря для определения условия when",
    },
    # when config validation
    "workflow.regex_must_be_dict": {
        "en": "regex condition must be a dictionary object",
        "zh": "regex 条件必须是字典对象",
        "ja": "regex 条件は辞書オブジェクトでなければなりません",
        "ar": "شرط regex يجب أن يكون كائن قاموس",
        "ru": "Условие regex должно быть объектом-словарем",
    },
    "workflow.regex_dict_suggestion": {
        "en": "Please use dictionary format to define regex condition",
        "zh": "请使用字典格式定义 regex 条件",
        "ja": "辞書形式で regex 条件を定義してください",
        "ar": "يرجى استخدام تنسيق القاموس لتعريف شرط regex",
        "ru": "Используйте формат словаря для определения условия regex",
    },
    "workflow.regex_missing_pattern": {
        "en": "regex condition missing pattern field",
        "zh": "regex 条件缺少 pattern 字段",
        "ja": "regex 条件に pattern フィールドがありません",
        "ar": "شرط regex يفتقد حقل pattern",
        "ru": "В условии regex отсутствует поле pattern",
    },
    "workflow.regex_pattern_suggestion": {
        "en": "Please provide a valid regex pattern",
        "zh": "请提供有效的正则表达式 pattern",
        "ja": "有効な正規表現 pattern を提供してください",
        "ar": "يرجى توفير نمط regex صالح",
        "ru": "Укажите допустимый шаблон регулярного выражения",
    },
    "workflow.jsonpath_must_be_dict": {
        "en": "jsonpath condition must be a dictionary object",
        "zh": "jsonpath 条件必须是字典对象",
        "ja": "jsonpath 条件は辞書オブジェクトでなければなりません",
        "ar": "شرط jsonpath يجب أن يكون كائن قاموس",
        "ru": "Условие jsonpath должно быть объектом-словарем",
    },
    "workflow.jsonpath_dict_suggestion": {
        "en": "Please use dictionary format to define jsonpath condition",
        "zh": "请使用字典格式定义 jsonpath 条件",
        "ja": "辞書形式で jsonpath 条件を定義してください",
        "ar": "يرجى استخدام تنسيق القاموس لتعريف شرط jsonpath",
        "ru": "Используйте формат словаря для определения условия jsonpath",
    },
    "workflow.jsonpath_missing_path": {
        "en": "jsonpath condition missing path field",
        "zh": "jsonpath 条件缺少 path 字段",
        "ja": "jsonpath 条件に path フィールドがありません",
        "ar": "شرط jsonpath يفتقد حقل path",
        "ru": "В условии jsonpath отсутствует поле path",
    },
    "workflow.jsonpath_path_suggestion": {
        "en": "Please provide a valid JSONPath expression, e.g., '$.files'",
        "zh": "请提供有效的 JSONPath 表达式，如 '$.files'",
        "ja": "有効な JSONPath 式を提供してください。例: '$.files'",
        "ar": "يرجى توفير تعبير JSONPath صالح، مثل '$.files'",
        "ru": "Укажите допустимое выражение JSONPath, например '$.files'",
    },
    "workflow.text_must_be_dict": {
        "en": "text condition must be a dictionary object",
        "zh": "text 条件必须是字典对象",
        "ja": "text 条件は辞書オブジェクトでなければなりません",
        "ar": "شرط text يجب أن يكون كائن قاموس",
        "ru": "Условие text должно быть объектом-словарем",
    },
    "workflow.text_dict_suggestion": {
        "en": "Please use dictionary format to define text condition",
        "zh": "请使用字典格式定义 text 条件",
        "ja": "辞書形式で text 条件を定義してください",
        "ar": "يرجى استخدام تنسيق القاموس لتعريف شرط text",
        "ru": "Используйте формат словаря для определения условия text",
    },
    "workflow.text_missing_input": {
        "en": "text condition missing input field",
        "zh": "text 条件缺少 input 字段",
        "ja": "text 条件に input フィールドがありません",
        "ar": "شرط text يفتقد حقل input",
        "ru": "В условии text отсутствует поле input",
    },
    "workflow.text_input_suggestion": {
        "en": "Please provide input field, e.g., '${steps.step1.outputs.result}'",
        "zh": "请提供 input 字段，如 '${steps.step1.outputs.result}'",
        "ja": "input フィールドを提供してください。例: '${steps.step1.outputs.result}'",
        "ar": "يرجى توفير حقل input، مثل '${steps.step1.outputs.result}'",
        "ru": "Укажите поле input, например '${steps.step1.outputs.result}'",
    },
    "workflow.text_missing_match_condition": {
        "en": "text condition requires at least one match condition",
        "zh": "text 条件至少需要一个匹配条件",
        "ja": "text 条件には少なくとも1つのマッチ条件が必要です",
        "ar": "شرط text يتطلب شرط مطابقة واحد على الأقل",
        "ru": "Условие text требует хотя бы одно условие сопоставления",
    },
    "workflow.text_match_suggestion": {
        "en": "Please add a match condition, e.g., contains, not_contains, is_empty, etc.",
        "zh": "请添加匹配条件，如 contains, not_contains, is_empty 等",
        "ja": "マッチ条件を追加してください。例: contains, not_contains, is_empty など",
        "ar": "يرجى إضافة شرط مطابقة، مثل contains, not_contains, is_empty إلخ",
        "ru": "Добавьте условие сопоставления, например contains, not_contains, is_empty и т.д.",
    },
    # output config validation
    "workflow.output_missing_method": {
        "en": "output config must specify at least one extraction method",
        "zh": "output 配置必须指定至少一种提取方法",
        "ja": "output 設定には少なくとも1つの抽出方法を指定する必要があります",
        "ar": "تكوين output يجب أن يحدد طريقة استخراج واحدة على الأقل",
        "ru": "Конфигурация output должна указывать хотя бы один метод извлечения",
    },
    "workflow.output_method_suggestion": {
        "en": "Use jsonpath, regex, or template for extraction",
        "zh": "使用 jsonpath、regex 或 template 进行提取",
        "ja": "抽出には jsonpath、regex、または template を使用してください",
        "ar": "استخدم jsonpath أو regex أو template للاستخراج",
        "ru": "Используйте jsonpath, regex или template для извлечения",
    },
    "workflow.output_invalid_format": {
        "en": "output config format is incorrect",
        "zh": "output 配置格式不正确",
        "ja": "output 設定の形式が正しくありません",
        "ar": "تنسيق تكوين output غير صحيح",
        "ru": "Неправильный формат конфигурации output",
    },
    "workflow.output_format_suggestion": {
        "en": "Please use correct format: { jsonpath: '$.key' } or template string '${attempt_result}'",
        "zh": "请使用正确格式: { jsonpath: '$.key' } 或模板字符串 '${attempt_result}'",
        "ja": "正しい形式を使用してください: { jsonpath: '$.key' } またはテンプレート文字列 '${attempt_result}'",
        "ar": "يرجى استخدام التنسيق الصحيح: { jsonpath: '$.key' } أو سلسلة القالب '${attempt_result}'",
        "ru": "Используйте правильный формат: { jsonpath: '$.key' } или строку шаблона '${attempt_result}'",
    },
    # conversation config validation
    "workflow.invalid_conversation_action": {
        "en": "Invalid conversation action",
        "zh": "无效的 conversation action",
        "ja": "無効な conversation action",
        "ar": "إجراء conversation غير صالح",
        "ru": "Недопустимое действие conversation",
    },
    "workflow.conversation_action_suggestion": {
        "en": "action value must be one of: resume, new, continue",
        "zh": "action 值必须是以下之一: resume, new, continue",
        "ja": "action 値は次のいずれかでなければなりません: resume, new, continue",
        "ar": "قيمة action يجب أن تكون واحدة من: resume, new, continue",
        "ru": "Значение action должно быть одним из: resume, new, continue",
    },
    "workflow.invalid_default_action": {
        "en": "Invalid conversation.default_action value",
        "zh": "conversation.default_action 值无效",
        "ja": "conversation.default_action 値が無効です",
        "ar": "قيمة conversation.default_action غير صالحة",
        "ru": "Недопустимое значение conversation.default_action",
    },
    "workflow.default_action_suggestion": {
        "en": "default_action value must be one of: resume, new, continue",
        "zh": "default_action 值必须是以下之一: resume, new, continue",
        "ja": "default_action 値は次のいずれかでなければなりません: resume, new, continue",
        "ar": "قيمة default_action يجب أن تكون واحدة من: resume, new, continue",
        "ru": "Значение default_action должно быть одним из: resume, new, continue",
    },
    # attempt config validation
    "workflow.invalid_attempt_format": {
        "en": "Invalid attempt.format value",
        "zh": "attempt.format 值无效",
        "ja": "attempt.format 値が無効です",
        "ar": "قيمة attempt.format غير صالحة",
        "ru": "Недопустимое значение attempt.format",
    },
    "workflow.attempt_format_suggestion": {
        "en": "format value must be 'json' or 'text'",
        "zh": "format 值必须是 'json' 或 'text'",
        "ja": "format 値は 'json' または 'text' でなければなりません",
        "ar": "قيمة format يجب أن تكون 'json' أو 'text'",
        "ru": "Значение format должно быть 'json' или 'text'",
    },
    "workflow.jsonpaths_must_be_dict": {
        "en": "attempt.jsonpaths must be a dictionary object",
        "zh": "attempt.jsonpaths 必须是字典对象",
        "ja": "attempt.jsonpaths は辞書オブジェクトでなければなりません",
        "ar": "attempt.jsonpaths يجب أن يكون كائن قاموس",
        "ru": "attempt.jsonpaths должен быть объектом-словарем",
    },
    "workflow.jsonpaths_dict_suggestion": {
        "en": "Define jsonpaths as key-value pairs, where value is a JSONPath expression",
        "zh": "将 jsonpaths 定义为键值对，其中值是 JSONPath 表达式",
        "ja": "jsonpaths をキー値ペアとして定義し、値は JSONPath 式にしてください",
        "ar": "عرّف jsonpaths كأزواج مفتاح-قيمة، حيث القيمة هي تعبير JSONPath",
        "ru": "Определите jsonpaths как пары ключ-значение, где значение - выражение JSONPath",
    },
    # required field validation
    "workflow.missing_required_field": {
        "en": "Missing required field: '{{field}}'",
        "zh": "缺少必需字段: '{{field}}'",
        "ja": "必須フィールドがありません: '{{field}}'",
        "ar": "حقل مطلوب مفقود: '{{field}}'",
        "ru": "Отсутствует обязательное поле: '{{field}}'",
    },
    "workflow.field_cannot_be_empty": {
        "en": "Field '{{field}}' cannot be empty",
        "zh": "字段 '{{field}}' 不能为空",
        "ja": "フィールド '{{field}}' は空にできません",
        "ar": "الحقل '{{field}}' لا يمكن أن يكون فارغاً",
        "ru": "Поле '{{field}}' не может быть пустым",
    },
    # Common field names
    "workflow.dict_object": {
        "en": "dictionary object",
        "zh": "字典对象",
        "ja": "辞書オブジェクト",
        "ar": "كائن قاموس",
        "ru": "объект-словарь",
    },
    "workflow.list_array": {
        "en": "list (array)",
        "zh": "列表（数组）",
        "ja": "リスト（配列）",
        "ar": "قائمة (مصفوفة)",
        "ru": "список (массив)",
    },
    "workflow.non_empty_string": {
        "en": "non-empty string",
        "zh": "非空字符串",
        "ja": "空でない文字列",
        "ar": "سلسلة غير فارغة",
        "ru": "непустая строка",
    },
    "workflow.positive_integer": {
        "en": "positive integer (>= 1)",
        "zh": "正整数（>= 1）",
        "ja": "正の整数 (>= 1)",
        "ar": "عدد صحيح موجب (>= 1)",
        "ru": "положительное целое число (>= 1)",
    },
    "workflow.empty_list": {
        "en": "empty list",
        "zh": "空列表",
        "ja": "空のリスト",
        "ar": "قائمة فارغة",
        "ru": "пустой список",
    },
    "workflow.at_least_one_agent": {
        "en": "at least one agent definition",
        "zh": "至少一个 agent 定义",
        "ja": "少なくとも1つのエージェント定義",
        "ar": "تعريف وكيل واحد على الأقل",
        "ru": "хотя бы одно определение агента",
    },
    "workflow.at_least_one_step": {
        "en": "at least one step definition",
        "zh": "至少一个 step 定义",
        "ja": "少なくとも1つのステップ定義",
        "ar": "تعريف خطوة واحدة على الأقل",
        "ru": "хотя бы одно определение шага",
    },
    "workflow.non_empty_regex": {
        "en": "non-empty regex expression",
        "zh": "非空正则表达式",
        "ja": "空でない正規表現",
        "ar": "تعبير منتظم غير فارغ",
        "ru": "непустое регулярное выражение",
    },
    "workflow.non_empty_jsonpath": {
        "en": "non-empty JSONPath expression",
        "zh": "非空 JSONPath 表达式",
        "ja": "空でない JSONPath 式",
        "ar": "تعبير JSONPath غير فارغ",
        "ru": "непустое выражение JSONPath",
    },
    "workflow.input_template": {
        "en": "input template string",
        "zh": "输入模板字符串",
        "ja": "入力テンプレート文字列",
        "ar": "سلسلة قالب الإدخال",
        "ru": "строка шаблона ввода",
    },
    # WorkflowValidationError
    "workflow.validation_error_title": {
        "en": "❌ Workflow Validation Error",
        "zh": "❌ Workflow 验证错误",
        "ja": "❌ Workflow 検証エラー",
        "ar": "❌ خطأ في التحقق من Workflow",
        "ru": "❌ Ошибка валидации Workflow",
    },
    "workflow.field_path": {
        "en": "Field Path",
        "zh": "字段路径",
        "ja": "フィールドパス",
        "ar": "مسار الحقل",
        "ru": "Путь к полю",
    },
    "workflow.expected_value": {
        "en": "Expected",
        "zh": "期望值",
        "ja": "期待値",
        "ar": "القيمة المتوقعة",
        "ru": "Ожидается",
    },
    "workflow.actual_value": {
        "en": "Actual",
        "zh": "实际值",
        "ja": "実際の値",
        "ar": "القيمة الفعلية",
        "ru": "Фактически",
    },
    "workflow.fix_suggestion": {
        "en": "💡 Fix Suggestion",
        "zh": "💡 修复建议",
        "ja": "💡 修正提案",
        "ar": "💡 اقتراح الإصلاح",
        "ru": "💡 Предложение по исправлению",
    },
    # WorkflowFileNotFoundError
    "workflow.file_not_found_title": {
        "en": "❌ Workflow File Not Found",
        "zh": "❌ Workflow 文件未找到",
        "ja": "❌ Workflow ファイルが見つかりません",
        "ar": "❌ ملف Workflow غير موجود",
        "ru": "❌ Файл Workflow не найден",
    },
    "workflow.searched_paths": {
        "en": "Searched Paths",
        "zh": "已搜索的路径",
        "ja": "検索されたパス",
        "ar": "المسارات المبحوثة",
        "ru": "Поиск по путям",
    },
    "workflow.please_check": {
        "en": "💡 Please Check",
        "zh": "💡 请检查",
        "ja": "💡 確認事項",
        "ar": "💡 يرجى التحقق",
        "ru": "💡 Пожалуйста, проверьте",
    },
    "workflow.check_name_correct": {
        "en": "1. workflow name is correct",
        "zh": "1. workflow 名称是否正确",
        "ja": "1. workflow 名が正しいか",
        "ar": "1. اسم workflow صحيح",
        "ru": "1. имя workflow правильное",
    },
    "workflow.check_file_exists": {
        "en": "2. workflow file exists in one of the following directories",
        "zh": "2. workflow 文件是否存在于以下目录之一",
        "ja": "2. workflow ファイルが次のディレクトリのいずれかに存在するか",
        "ar": "2. ملف workflow موجود في أحد الدلائل التالية",
        "ru": "2. файл workflow существует в одной из следующих директорий",
    },
    # WorkflowParseError
    "workflow.parse_error_title": {
        "en": "❌ Workflow YAML Parse Error",
        "zh": "❌ Workflow YAML 解析错误",
        "ja": "❌ Workflow YAML 解析エラー",
        "ar": "❌ خطأ في تحليل Workflow YAML",
        "ru": "❌ Ошибка парсинга Workflow YAML",
    },
    "workflow.file": {
        "en": "File",
        "zh": "文件",
        "ja": "ファイル",
        "ar": "الملف",
        "ru": "Файл",
    },
    "workflow.line_number": {
        "en": "Line",
        "zh": "行号",
        "ja": "行番号",
        "ar": "رقم السطر",
        "ru": "Строка",
    },
    "workflow.error_type": {
        "en": "Error Type",
        "zh": "错误类型",
        "ja": "エラー種別",
        "ar": "نوع الخطأ",
        "ru": "Тип ошибки",
    },
    "workflow.error_details": {
        "en": "Error Details",
        "zh": "错误详情",
        "ja": "エラー詳細",
        "ar": "تفاصيل الخطأ",
        "ru": "Подробности ошибки",
    },
    "workflow.common_issues": {
        "en": "💡 Common Issues",
        "zh": "💡 常见问题",
        "ja": "💡 よくある問題",
        "ar": "💡 المشكلات الشائعة",
        "ru": "💡 Частые проблемы",
    },
    "workflow.check_yaml_syntax": {
        "en": "- Check YAML syntax (indentation, colons, quotes)",
        "zh": "- 检查 YAML 语法是否正确（缩进、冒号、引号）",
        "ja": "- YAML 構文を確認（インデント、コロン、引用符）",
        "ar": "- تحقق من بناء YAML الصحيح (المسافة البادئة، النقطتان، علامات الاقتباس)",
        "ru": "- Проверьте синтаксис YAML (отступы, двоеточия, кавычки)",
    },
    "workflow.no_tab_characters": {
        "en": "- Ensure no Tab characters (YAML only supports spaces)",
        "zh": "- 确保没有使用 Tab 字符（YAML 只支持空格）",
        "ja": "- Tab 文字を使用していないことを確認（YAMLはスペースのみサポート）",
        "ar": "- تأكد من عدم استخدام أحرف Tab (YAML يدعم المسافات فقط)",
        "ru": "- Убедитесь, что нет символов Tab (YAML поддерживает только пробелы)",
    },
    "workflow.check_special_chars": {
        "en": "- Verify special characters are properly escaped",
        "zh": "- 验证特殊字符是否正确转义",
        "ja": "- 特殊文字が適切にエスケープされているか確認",
        "ar": "- تحقق من تجاهل الأحرف الخاصة بشكل صحيح",
        "ru": "- Проверьте правильное экранирование специальных символов",
    },
    # WorkflowStepError
    "workflow.step_error_title": {
        "en": "❌ Workflow Step Execution Error",
        "zh": "❌ Workflow 步骤执行错误",
        "ja": "❌ Workflow ステップ実行エラー",
        "ar": "❌ خطأ في تنفيذ خطوة Workflow",
        "ru": "❌ Ошибка выполнения шага Workflow",
    },
    "workflow.step_id": {
        "en": "Step ID",
        "zh": "步骤 ID",
        "ja": "ステップ ID",
        "ar": "معرف الخطوة",
        "ru": "ID шага",
    },
    "workflow.agent_id": {
        "en": "Agent ID",
        "zh": "代理 ID",
        "ja": "エージェント ID",
        "ar": "معرف الوكيل",
        "ru": "ID агента",
    },
    "workflow.error": {
        "en": "Error",
        "zh": "错误",
        "ja": "エラー",
        "ar": "خطأ",
        "ru": "Ошибка",
    },
    "workflow.cause_type": {
        "en": "Cause Type",
        "zh": "原因类型",
        "ja": "原因タイプ",
        "ar": "نوع السبب",
        "ru": "Тип причины",
    },
    "workflow.cause_details": {
        "en": "Cause Details",
        "zh": "原因详情",
        "ja": "原因詳細",
        "ar": "تفاصيل السبب",
        "ru": "Подробности причины",
    },
    # WorkflowDependencyError
    "workflow.dependency_error_title": {
        "en": "❌ Workflow Dependency Error",
        "zh": "❌ Workflow 依赖错误",
        "ja": "❌ Workflow 依存関係エラー",
        "ar": "❌ خطأ في تبعية Workflow",
        "ru": "❌ Ошибка зависимостей Workflow",
    },
    "workflow.involved_step": {
        "en": "Involved Step",
        "zh": "涉及步骤",
        "ja": "関連ステップ",
        "ar": "الخطوة المعنية",
        "ru": "Затронутый шаг",
    },
    "workflow.dependency_chain": {
        "en": "Dependency Chain",
        "zh": "依赖链",
        "ja": "依存チェーン",
        "ar": "سلسلة التبعية",
        "ru": "Цепочка зависимостей",
    },
    "workflow.check_needs_field": {
        "en": "- Check if steps referenced in 'needs' field exist",
        "zh": "- 检查 needs 字段引用的步骤是否存在",
        "ja": "- 'needs' フィールドで参照されているステップが存在するか確認",
        "ar": "- تحقق من وجود الخطوات المشار إليها في حقل 'needs'",
        "ru": "- Проверьте существование шагов, на которые ссылается поле 'needs'",
    },
    "workflow.no_circular_dependency": {
        "en": "- Ensure no circular dependencies (A depends on B, B depends on A)",
        "zh": "- 确保没有循环依赖（A依赖B，B依赖A）",
        "ja": "- 循環依存がないことを確認（AがBに依存、BがAに依存）",
        "ar": "- تأكد من عدم وجود تبعيات دائرية (A يعتمد على B، B يعتمد على A)",
        "ru": "- Убедитесь в отсутствии циклических зависимостей (A зависит от B, B зависит от A)",
    },
    "workflow.check_step_id_spelling": {
        "en": "- Verify step ID spelling in dependencies",
        "zh": "- 验证依赖的步骤 ID 拼写是否正确",
        "ja": "- 依存関係のステップ ID のスペルを確認",
        "ar": "- تحقق من تهجئة معرف الخطوة في التبعيات",
        "ru": "- Проверьте правильность написания ID шага в зависимостях",
    },
    # WorkflowAgentNotFoundError
    "workflow.agent_not_found_title": {
        "en": "❌ Workflow Agent Not Found",
        "zh": "❌ Workflow 代理不存在",
        "ja": "❌ Workflow エージェントが見つかりません",
        "ar": "❌ وكيل Workflow غير موجود",
        "ru": "❌ Агент Workflow не найден",
    },
    "workflow.referenced_agent": {
        "en": "Referenced Agent",
        "zh": "引用的代理",
        "ja": "参照されたエージェント",
        "ar": "الوكيل المشار إليه",
        "ru": "Ссылаемый агент",
    },
    "workflow.in_step": {
        "en": "In Step",
        "zh": "所在步骤",
        "ja": "所在ステップ",
        "ar": "في الخطوة",
        "ru": "В шаге",
    },
    "workflow.available_agents": {
        "en": "Available Agents",
        "zh": "可用的代理",
        "ja": "利用可能なエージェント",
        "ar": "الوكلاء المتاحون",
        "ru": "Доступные агенты",
    },
    "workflow.no_agents": {
        "en": "(none)",
        "zh": "(无)",
        "ja": "(なし)",
        "ar": "(لا يوجد)",
        "ru": "(нет)",
    },
    "workflow.check_agent_spelling": {
        "en": "- Check if agent field spelling is correct in steps",
        "zh": "- 检查步骤中的 agent 字段拼写是否正确",
        "ja": "- ステップのエージェントフィールドのスペルが正しいか確認",
        "ar": "- تحقق من صحة تهجئة حقل الوكيل في الخطوات",
        "ru": "- Проверьте правильность написания поля agent в шагах",
    },
    "workflow.ensure_agent_defined": {
        "en": "- Ensure the agent is defined in spec.agents",
        "zh": "- 确保在 spec.agents 中定义了该代理",
        "ja": "- spec.agents でエージェントが定義されているか確認",
        "ar": "- تأكد من تعريف الوكيل في spec.agents",
        "ru": "- Убедитесь, что агент определен в spec.agents",
    },
    # WorkflowTemplateError
    "workflow.template_error_title": {
        "en": "❌ Workflow Template Rendering Error",
        "zh": "❌ Workflow 模板渲染错误",
        "ja": "❌ Workflow テンプレートレンダリングエラー",
        "ar": "❌ خطأ في عرض قالب Workflow",
        "ru": "❌ Ошибка рендеринга шаблона Workflow",
    },
    "workflow.expression": {
        "en": "Expression",
        "zh": "表达式",
        "ja": "式",
        "ar": "التعبير",
        "ru": "Выражение",
    },
    "workflow.template_snippet": {
        "en": "Template Snippet",
        "zh": "模板片段",
        "ja": "テンプレートスニペット",
        "ar": "مقتطف القالب",
        "ru": "Фрагмент шаблона",
    },
    "workflow.available_context_keys": {
        "en": "Available Context Keys",
        "zh": "当前上下文可用的键",
        "ja": "利用可能なコンテキストキー",
        "ar": "مفاتيح السياق المتاحة",
        "ru": "Доступные ключи контекста",
    },
    "workflow.check_expression_syntax": {
        "en": "- Check expression syntax: ${vars.key}, ${steps.stepId.outputs.key}",
        "zh": "- 检查表达式语法: ${vars.key}, ${steps.stepId.outputs.key}",
        "ja": "- 式の構文を確認: ${vars.key}, ${steps.stepId.outputs.key}",
        "ar": "- تحقق من بناء التعبير: ${vars.key}, ${steps.stepId.outputs.key}",
        "ru": "- Проверьте синтаксис выражения: ${vars.key}, ${steps.stepId.outputs.key}",
    },
    "workflow.ensure_variable_defined": {
        "en": "- Ensure referenced variables or step outputs are defined",
        "zh": "- 确保引用的变量或步骤输出已定义",
        "ja": "- 参照される変数またはステップ出力が定義されているか確認",
        "ar": "- تأكد من تعريف المتغيرات أو مخرجات الخطوات المشار إليها",
        "ru": "- Убедитесь, что ссылаемые переменные или выходы шагов определены",
    },
    "workflow.check_execution_order": {
        "en": "- Verify step execution order (can only reference outputs from executed steps)",
        "zh": "- 验证步骤执行顺序（只能引用已执行步骤的输出）",
        "ja": "- ステップ実行順序を確認（実行済みステップの出力のみ参照可能）",
        "ar": "- تحقق من ترتيب تنفيذ الخطوات (يمكن الإشارة فقط إلى مخرجات الخطوات المنفذة)",
        "ru": "- Проверьте порядок выполнения шагов (можно ссылаться только на выходы выполненных шагов)",
    },
    # WorkflowAgentDefinitionError
    "workflow.agent_definition_error_title": {
        "en": "❌ Workflow Agent Definition Error",
        "zh": "❌ Workflow 代理定义错误",
        "ja": "❌ Workflow エージェント定義エラー",
        "ar": "❌ خطأ في تعريف وكيل Workflow",
        "ru": "❌ Ошибка определения агента Workflow",
    },
    "workflow.agent_path": {
        "en": "Agent Path",
        "zh": "代理路径",
        "ja": "エージェントパス",
        "ar": "مسار الوكيل",
        "ru": "Путь агента",
    },
    "workflow.check_agent_file_exists": {
        "en": "- Check if agent file exists in .autocoderagents/ directory",
        "zh": "- 检查代理文件是否存在于 .autocoderagents/ 目录",
        "ja": "- エージェントファイルが .autocoderagents/ ディレクトリに存在するか確認",
        "ar": "- تحقق من وجود ملف الوكيل في دليل .autocoderagents/",
        "ru": "- Проверьте существование файла агента в директории .autocoderagents/",
    },
    "workflow.ensure_agent_content_valid": {
        "en": "- Ensure agent file content meets format requirements",
        "zh": "- 确保代理文件内容符合格式要求",
        "ja": "- エージェントファイルの内容が形式要件を満たしているか確認",
        "ar": "- تأكد من أن محتوى ملف الوكيل يلبي متطلبات التنسيق",
        "ru": "- Убедитесь, что содержимое файла агента соответствует требованиям формата",
    },
    "workflow.check_path_spelling": {
        "en": "- Verify agent file path spelling is correct",
        "zh": "- 验证代理文件路径拼写是否正确",
        "ja": "- エージェントファイルパスのスペルが正しいか確認",
        "ar": "- تحقق من صحة تهجئة مسار ملف الوكيل",
        "ru": "- Проверьте правильность написания пути к файлу агента",
    },
    # WorkflowConversationError
    "workflow.conversation_error_title": {
        "en": "❌ Workflow Conversation Management Error",
        "zh": "❌ Workflow 会话管理错误",
        "ja": "❌ Workflow 会話管理エラー",
        "ar": "❌ خطأ في إدارة محادثة Workflow",
        "ru": "❌ Ошибка управления беседой Workflow",
    },
    "workflow.conversation_action": {
        "en": "Conversation Action",
        "zh": "会话动作",
        "ja": "会話アクション",
        "ar": "إجراء المحادثة",
        "ru": "Действие беседы",
    },
    "workflow.conversation_id": {
        "en": "Conversation ID",
        "zh": "会话 ID",
        "ja": "会話 ID",
        "ar": "معرف المحادثة",
        "ru": "ID беседы",
    },
    # WorkflowConditionError
    "workflow.condition_error_title": {
        "en": "❌ Workflow Condition Evaluation Error",
        "zh": "❌ Workflow 条件评估错误",
        "ja": "❌ Workflow 条件評価エラー",
        "ar": "❌ خطأ في تقييم شرط Workflow",
        "ru": "❌ Ошибка оценки условия Workflow",
    },
    "workflow.condition_type": {
        "en": "Condition Type",
        "zh": "条件类型",
        "ja": "条件タイプ",
        "ar": "نوع الشرط",
        "ru": "Тип условия",
    },
    "workflow.condition_details": {
        "en": "Condition Details",
        "zh": "条件详情",
        "ja": "条件詳細",
        "ar": "تفاصيل الشرط",
        "ru": "Подробности условия",
    },
    "workflow.check_when_syntax": {
        "en": "- Check 'when' condition syntax is correct",
        "zh": "- 检查 when 条件的语法是否正确",
        "ja": "- 'when' 条件の構文が正しいか確認",
        "ar": "- تحقق من صحة بناء شرط 'when'",
        "ru": "- Проверьте правильность синтаксиса условия 'when'",
    },
    "workflow.verify_regex_pattern": {
        "en": "- Verify regex pattern is valid",
        "zh": "- 验证正则表达式模式是否有效",
        "ja": "- 正規表現パターンが有効か確認",
        "ar": "- تحقق من صحة نمط التعبير المنتظم",
        "ru": "- Проверьте действительность шаблона регулярного выражения",
    },
    "workflow.ensure_jsonpath_correct": {
        "en": "- Ensure JSONPath expression format is correct",
        "zh": "- 确保 JSONPath 表达式格式正确",
        "ja": "- JSONPath 式の形式が正しいか確認",
        "ar": "- تأكد من صحة تنسيق تعبير JSONPath",
        "ru": "- Убедитесь, что формат выражения JSONPath правильный",
    },
    # WorkflowOutputExtractionError
    "workflow.output_extraction_error_title": {
        "en": "❌ Workflow Output Extraction Error",
        "zh": "❌ Workflow 输出提取错误",
        "ja": "❌ Workflow 出力抽出エラー",
        "ar": "❌ خطأ في استخراج مخرجات Workflow",
        "ru": "❌ Ошибка извлечения выхода Workflow",
    },
    "workflow.output_key": {
        "en": "Output Key",
        "zh": "输出键",
        "ja": "出力キー",
        "ar": "مفتاح الإخراج",
        "ru": "Ключ вывода",
    },
    "workflow.extraction_method": {
        "en": "Extraction Method",
        "zh": "提取方法",
        "ja": "抽出方法",
        "ar": "طريقة الاستخراج",
        "ru": "Метод извлечения",
    },
    "workflow.check_jsonpath_expression": {
        "en": "- Check if JSONPath expression is correct",
        "zh": "- 检查 JSONPath 表达式是否正确",
        "ja": "- JSONPath 式が正しいか確認",
        "ar": "- تحقق من صحة تعبير JSONPath",
        "ru": "- Проверьте правильность выражения JSONPath",
    },
    "workflow.verify_regex_and_group": {
        "en": "- Verify regex pattern and grouping",
        "zh": "- 验证正则表达式模式和分组",
        "ja": "- 正規表現パターンとグループを確認",
        "ar": "- تحقق من نمط التعبير المنتظم والتجميع",
        "ru": "- Проверьте шаблон регулярного выражения и группировку",
    },
    "workflow.ensure_format_matches": {
        "en": "- Ensure attempt_result format matches extraction method",
        "zh": "- 确保 attempt_result 格式与提取方法匹配",
        "ja": "- attempt_result の形式が抽出方法と一致するか確認",
        "ar": "- تأكد من تطابق تنسيق attempt_result مع طريقة الاستخراج",
        "ru": "- Убедитесь, что формат attempt_result соответствует методу извлечения",
    },
    # WorkflowAgentResolutionError
    "workflow.agent_resolution_error_title": {
        "en": "❌ Workflow Agent Resolution Error",
        "zh": "❌ Workflow 代理解析错误",
        "ja": "❌ Workflow エージェント解決エラー",
        "ar": "❌ خطأ في حل وكيل Workflow",
        "ru": "❌ Ошибка разрешения агента Workflow",
    },
    "workflow.agent_resolution_failed": {
        "en": "Failed to resolve agent definition file",
        "zh": "无法解析代理定义文件",
        "ja": "エージェント定義ファイルの解決に失敗しました",
        "ar": "فشل في حل ملف تعريف الوكيل",
        "ru": "Не удалось разрешить файл определения агента",
    },
    "workflow.agent_not_found_at_path": {
        "en": "Agent file not found",
        "zh": "未找到代理文件",
        "ja": "エージェントファイルが見つかりません",
        "ar": "ملف الوكيل غير موجود",
        "ru": "Файл агента не найден",
    },
    "workflow.searched_agent_paths": {
        "en": "Searched Paths",
        "zh": "已搜索的路径",
        "ja": "検索されたパス",
        "ar": "المسارات المبحوثة",
        "ru": "Поиск по путям",
    },
    "workflow.check_agent_path_exists": {
        "en": "- Ensure agent definition file exists in one of the priority directories",
        "zh": "- 确保代理定义文件存在于优先级目录之一",
        "ja": "- エージェント定義ファイルが優先ディレクトリのいずれかに存在することを確認",
        "ar": "- تأكد من وجود ملف تعريف الوكيل في أحد الدلائل ذات الأولوية",
        "ru": "- Убедитесь, что файл определения агента существует в одной из приоритетных директорий",
    },
    "workflow.verify_agent_path_correct": {
        "en": "- Verify agent path in YAML configuration is correct",
        "zh": "- 验证 YAML 配置中的代理路径是否正确",
        "ja": "- YAML 設定のエージェントパスが正しいか確認",
        "ar": "- تحقق من صحة مسار الوكيل في تكوين YAML",
        "ru": "- Проверьте правильность пути агента в конфигурации YAML",
    },
    # WorkflowModelValidationError
    "workflow.model_validation_error_title": {
        "en": "❌ Workflow Model Validation Error",
        "zh": "❌ Workflow 模型验证错误",
        "ja": "❌ Workflow モデル検証エラー",
        "ar": "❌ خطأ في التحقق من نموذج Workflow",
        "ru": "❌ Ошибка валидации модели Workflow",
    },
    "workflow.model_not_found": {
        "en": "Model not found",
        "zh": "未找到模型",
        "ja": "モデルが見つかりません",
        "ar": "النموذج غير موجود",
        "ru": "Модель не найдена",
    },
    "workflow.model_key_missing": {
        "en": "API key is not configured for model",
        "zh": "模型未配置 API 密钥",
        "ja": "モデルの API キーが設定されていません",
        "ar": "مفتاح API غير مكون للنموذج",
        "ru": "API ключ не настроен для модели",
    },
    "workflow.model_validation_failed": {
        "en": "Model validation failed",
        "zh": "模型验证失败",
        "ja": "モデル検証に失敗しました",
        "ar": "فشل التحقق من النموذج",
        "ru": "Проверка модели не удалась",
    },
    "workflow.model_name": {
        "en": "Model Name",
        "zh": "模型名称",
        "ja": "モデル名",
        "ar": "اسم النموذج",
        "ru": "Имя модели",
    },
    "workflow.check_model_registered": {
        "en": "- Ensure model is registered in LLM configuration",
        "zh": "- 确保模型已在 LLM 配置中注册",
        "ja": "- モデルが LLM 設定に登録されているか確認",
        "ar": "- تأكد من تسجيل النموذج في تكوين LLM",
        "ru": "- Убедитесь, что модель зарегистрирована в конфигурации LLM",
    },
    "workflow.check_api_key_configured": {
        "en": "- Verify API key is configured for the model",
        "zh": "- 验证模型的 API 密钥是否已配置",
        "ja": "- モデルの API キーが設定されているか確認",
        "ar": "- تحقق من تكوين مفتاح API للنموذج",
        "ru": "- Проверьте настройку API ключа для модели",
    },
    "workflow.check_model_name_spelling": {
        "en": "- Check model name spelling in configuration",
        "zh": "- 检查配置中的模型名称拼写",
        "ja": "- 設定のモデル名のスペルを確認",
        "ar": "- تحقق من تهجئة اسم النموذج في التكوين",
        "ru": "- Проверьте правильность написания имени модели в конфигурации",
    },
    # Executor runtime messages
    "workflow.exec_render_input_failed": {
        "en": "Failed to render input: {{error}}",
        "zh": "渲染输入失败: {{error}}",
        "ja": "入力のレンダリングに失敗しました: {{error}}",
        "ar": "فشل في عرض الإدخال: {{error}}",
        "ru": "Не удалось отрендерить ввод: {{error}}",
    },
    "workflow.exec_agent_no_result": {
        "en": "Agent returned no result",
        "zh": "代理未返回结果",
        "ja": "エージェントは結果を返しませんでした",
        "ar": "لم يُرجع الوكيل أي نتيجة",
        "ru": "Агент не вернул результат",
    },
    "workflow.exec_replica_exception": {
        "en": "Replica {{idx}} execution exception: {{error}}",
        "zh": "副本 {{idx}} 执行异常: {{error}}",
        "ja": "レプリカ {{idx}} の実行例外: {{error}}",
        "ar": "استثناء تنفيذ النسخة {{idx}}: {{error}}",
        "ru": "Исключение при выполнении реплики {{idx}}: {{error}}",
    },
    "workflow.exec_all_replicas_failed": {
        "en": "All {{n}} replicas failed: {{errors}}",
        "zh": "所有 {{n}} 个副本都失败了: {{errors}}",
        "ja": "すべての {{n}} 個のレプリカが失敗しました: {{errors}}",
        "ar": "فشلت جميع النسخ {{n}}: {{errors}}",
        "ru": "Все {{n}} реплик завершились с ошибкой: {{errors}}",
    },
    "workflow.exec_all_filtered": {
        "en": "All {{n}} successful replicas were filtered by merge.when",
        "zh": "所有 {{n}} 个成功副本均未通过 merge.when 条件",
        "ja": "成功した {{n}} 個のレプリカがすべて merge.when によりフィルタされました",
        "ar": "تمت تصفية جميع {{n}} النسخ الناجحة بواسطة merge.when",
        "ru": "Все {{n}} успешных реплик были отфильтрованы merge.when",
    },
    "workflow.exec_exception": {
        "en": "Execution exception: {{error}}",
        "zh": "执行异常: {{error}}",
        "ja": "実行例外: {{error}}",
        "ar": "استثناء أثناء التنفيذ: {{error}}",
        "ru": "Исключение при выполнении: {{error}}",
    },
    "workflow.exec_toposort_failed": {
        "en": "Topological sort failed: {{error}}",
        "zh": "拓扑排序失败: {{error}}",
        "ja": "トポロジカルソートに失敗しました: {{error}}",
        "ar": "فشل الفرز الطوبولوجي: {{error}}",
        "ru": "Сбой топологической сортировки: {{error}}",
    },
    "workflow.exec_failed_steps_count": {
        "en": "{{n}} steps failed",
        "zh": "{{n}} 个步骤失败",
        "ja": "{{n}} 個のステップが失敗しました",
        "ar": "{{n}} خطوات فشلت",
        "ru": "Сбой в {{n}} шагах",
    },
}
