ხელოვნური ინტელექტის ამოცანების სისტემა

ხელოვნური ინტელექტის ამოცანების სისტემა არის მექანიზმი, რომლის საშუალებითაც OpenPR ანაწილებს სამუშაოს ხელოვნური ინტელექტის კოდირების აგენტებზე. ის ახდენს ხიდის ფუნქციას ადამიანის მიერ პროექტის მენეჯერში ამოცანის შექმნასა და ხელოვნური ინტელექტის აგენტის მიერ მისი გადაჭრისთვის კოდის ავტონომიურ წერას შორის.

მიმოხილვა

სისტემას ოთხი კომპონენტი აქვს:

API — ქმნის ამოცანებს, მართავს მდგომარეობას, იღებს გამოძახებებს აგენტებიდან
Worker — ფონური პროცესი, რომელიც ამოწმებს მომლოდინე ამოცანებს და აგზავნის მათ ვებჰუკებით
ვებჰუკი — HTTP POST აგენტის ბოლო წერტილზე ამოცანის დეტალებით
აგენტი — ხელოვნური ინტელექტის კოდირების ინსტრუმენტი (Codex, Claude Code, OpenCode), რომელიც ასრულებს ამოცანას და აბრუნებს ანგარიშს

ამოცანა მინიჭებულია ბოტზე
        |
        v
  API ქმნის ai_task-ს (სტატუსი: pending)
        |
        v
  Worker აიღებს ამოცანას (სტატუსი: processing)
        |
        v
  Worker აგზავნის ვებჰუკის POST-ით
        |
        v
  აგენტი ასრულებს (წერს კოდს, უშვებს ტესტებს)
        |
        v
  აგენტი იძახებს API გამოძახებას
        |
        v
  ამოცანა მონიშნულია დასრულებულად ან ჩავარდნილად

ამოცანის სასიცოცხლო ციკლი

მდგომარეობის გადასვლები

pending --> processing --> completed
    ^           |
    |           v
    +------- failed (თუ ხელახალი ცდები დარჩა, ბრუნდება pending-ზე)

სტატუსი	მნიშვნელობა
`pending`	ამოცანა რიგშია, ელოდება worker-ის აყვანას
`processing`	Worker-მა მოითხოვა ამოცანა და გაუგზავნა აგენტს
`completed`	აგენტმა შეატყობინა წარმატებული დასრულება
`failed`	აგენტმა შეატყობინა წარუმატებლობა ან ყველა ხელახალი ცდა ამოიწურა
`cancelled`	ამოცანა ხელით გაუქმდა

ხელახალი ცდის მექანიზმი

ყოველ ამოცანას აქვს კონფიგურირებადი max_attempts (ნაგულისხმევი: 3). როდესაც გაგზავნა ჩავარდება ან აგენტი შეატყობინებს წარუმატებლობას:

თუ attempts < max_attempts, ამოცანა ბრუნდება pending სტატუსზე next_retry_at დროის ნიშანით
ხელახალი ცდის დაყოვნება ხაზოვანია: attempts * 30 წამი, მაქსიმუმ 600 წამი (10 წუთი)
თუ ყველა ცდა ამოიწურა, ამოცანა გადადის failed სტატუსზე და ai.task_failed ვებჰუკის მოვლენა ისვრება

მოვლენების ჟურნალი

ყოველი მდგომარეობის გადასვლა ჩაიწერება ai_task_events ცხრილში დროის ნიშანიანი მოვლენის ტიპითა და პეილოადით:

მოვლენის ტიპი	როდის
`created`	ამოცანა თავდაპირველად შეიქმნა
`picked_up`	Worker-მა მოითხოვა ამოცანა დასამუშავებლად
`progress`	აგენტი ატყობინებს შუალედურ პროგრესს
`completed`	აგენტი ატყობინებს წარმატებულ დასრულებას
`retried`	ამოცანა ბრუნდება pending-ზე წარუმატებლობის შემდეგ
`failed`	ამოცანამ ამოწურა ყველა ხელახალი ცდა

ამოცანების ტიპები

სისტემა მხარს უჭერს ოთხი ტიპის ამოცანას:

ტიპი	აღწერა	მითითების ტიპი
`issue_assigned`	ამოცანა მინიჭებულია ბოტზე განხორციელებისთვის	`work_item`
`review_requested`	მოთხოვნილია კოდის ან წინადადების მიმოხილვა	`proposal`
`comment_requested`	ბოტს სთხოვენ კომენტარის გაკეთებას ამოცანაზე ან წინადადებაზე	`comment`
`vote_requested`	ბოტს სთხოვენ ხმის მიცემას მმართველობის წინადადებაზე	`proposal`

ბოტ-მომხმარებლები და ავტორიზაცია

ბოტ-მომხმარებლის ანგარიშები

ხელოვნური ინტელექტის აგენტები წარმოდგენილი არიან როგორც მომხმარებლები entity_type = 'bot'-ით. ისინი რეგისტრირებულია users ცხრილში, როგორც ნებისმიერი სხვა მომხმარებელი, მაგრამ ავტორიზდებიან განსხვავებულად.

ბოტის ტოკენები

ბოტის ტოკენები იყენებენ opr_ პრეფიქსს და მიბმულია სამუშაო სივრცეზე. ისინი ინახება workspace_bots ცხრილში SHA-256 ჰეშების სახით.

Authorization: Bearer opr_0a5bc81ea108dad8077decc880abced0d923aa873b9ff774575ec152aecf15d5

ბოტის ტოკენები შეიცავს:

ველი	აღწერა
`workspace_id`	სამუშაო სივრცე, რომელზეც ტოკენი მიბმულია
`permissions`	ნებართვების სტრიქონების მასივი (`read`, `write`, `admin`)
`is_active`	ტოკენი ამჟამად მოქმედია თუ არა
`expires_at`	არჩევითი ვადის გასვლის დროის ნიშანი
`last_used_at`	ავტომატურად განახლდება ყოველ API გამოძახებაზე

ხელოვნური ინტელექტის მონაწილეები

ბოტ-მომხმარებლები რეგისტრირებულია როგორც ხელოვნური ინტელექტის მონაწილეები კონკრეტულ პროექტებში ai_participants ცხრილის საშუალებით. ყოველ მონაწილეს აქვს:

ველი	აღწერა
`name`	საჩვენებელი სახელი (მაგ., “Claude Agent”)
`model`	მოდელის იდენტიფიკატორი (მაგ., “claude-opus-4”)
`provider`	პროვაიდერის სახელი (მაგ., “anthropic”)
`capabilities`	JSON ობიექტი, რომელიც აღწერს აგენტის შესაძლებლობებს
`max_domain_level`	ავტონომიის დონე: `observer`, `advisor`, `voter`, `vetoer`, `autonomous`
`can_veto_human_consensus`	შეუძლია თუ არა აგენტს ადამიანების ხმების გადაფარვა
`reason_min_length`	ხმის მიცემის დასაბუთების მინიმალური სიგრძე
`is_active`	მონაწილე ჩართულია თუ არა

Worker პროცესი

Worker არის დამოუკიდებელი Rust ბინარი, რომელიც მუშაობს როგორც ფონური სერვისი. ის ამოწმებს ai_tasks ცხრილს ყოველ 5 წამში მომლოდინე ამოცანებისთვის.

ამოცანის აყვანა

Worker იყენებს PostgreSQL-ის FOR UPDATE SKIP LOCKED-ს ამოცანების უსაფრთხოდ მოსათხოვნად კონკურენტულ გარემოში:

მოთხოვნა მომლოდინე ამოცანებზე, სადაც next_retry_at არის null ან წარსულში
ატომურად განახლებს მათ სტატუსს processing-ზე და ზრდის attempts-ს
ჩაწერს picked_up მოვლენას

ამოცანები დალაგებულია priority DESC, created_at ASC — მაღალი პრიორიტეტის ამოცანები მუშავდება პირველი, ძველი ამოცანები არღვევენ თანაბრობას.

გაგზავნა

ყოველი მოთხოვნილი ამოცანისთვის worker:

პოულობს აქტიურ ვებჰუკს ბოტ-მომხმარებლისთვის ამოცანის პროექტში
ქმნის გაგზავნის პეილოადს ამოცანის დეტალებით
აგზავნის HTTP POST-ს ვებჰუკის URL-ზე
თუ POST ჩავარდა, ჩაწერს წარუმატებლობას და ან ხელახლა ცდის, ან მონიშნავს ამოცანას წარუმატებლად

გაგზავნის პეილოადი

აგენტისთვის გაგზავნილი ვებჰუკის POST სხეული შეიცავს:

{
  "task_id": "uuid",
  "project_id": "uuid",
  "ai_participant_id": "uuid",
  "task_type": "issue_assigned",
  "reference_type": "work_item",
  "reference_id": "uuid",
  "payload": {
    "issue_title": "Fix authentication flow",
    "issue_description": "The login endpoint returns 500..."
  },
  "attempts": 1,
  "max_attempts": 3
}

კონკურენტულობა

Worker იღებს --concurrency ფლაგს (ნაგულისხმევი: 4), რომელიც აკონტროლებს რამდენი ამოცანა აიყვანება ყოველ გამოკითხვის ციკლში. ფაქტობრივი პაკეტის ზომაა concurrency * 10.

აგენტის გამოძახების API

ამოცანის შესრულების შემდეგ, აგენტი აბრუნებს შედეგებს OpenPR-ში REST API-ის საშუალებით.

ამოცანის დასრულება

POST /api/projects/:project_id/ai-tasks/:task_id/complete
Authorization: Bearer opr_...
Content-Type: application/json

{
  "summary": "Fixed the authentication flow by...",
  "files_changed": ["src/auth.rs", "src/middleware.rs"],
  "commit_sha": "abc123"
}

მოთხოვნის სხეული ინახება როგორც ამოცანის result ველი. ამოცანა გადადის completed სტატუსზე და ai.task_completed ვებჰუკის მოვლენა ისვრება.

ამოცანის ჩავარდნა

POST /api/projects/:project_id/ai-tasks/:task_id/fail
Authorization: Bearer opr_...
Content-Type: application/json

{
  "error_message": "Test suite failed with 3 errors",
  "payload": {
    "test_output": "..."
  }
}

თუ ამოცანას დარჩენილი ხელახალი ცდები აქვს, ის ბრუნდება pending-ზე დაყოვნებით. წინააღმდეგ შემთხვევაში, გადადის failed-ზე და ai.task_failed ვებჰუკის მოვლენა ისვრება.

პროგრესის ანგარიში

POST /api/projects/:project_id/ai-tasks/:task_id/progress
Authorization: Bearer opr_...
Content-Type: application/json

{
  "step": "running tests",
  "progress_pct": 75
}

პროგრესის ანგარიშები ჩაიწერება როგორც progress მოვლენები ai_task_events-ში, მაგრამ არ ცვლიან ამოცანის სტატუსს.

ამოცანების შექმნა

ავტომატური (ამოცანის მინიჭებით)

როდესაც ამოცანა მინიჭებულია ბოტ-მომხმარებელზე და არსებობს ვებჰუკი შესაბამისი bot_user_id-ით, ამოცანის მინიჭება იწვევს issue_assigned ხელოვნური ინტელექტის ამოცანის შექმნას.

ავტომატური (მმართველობით)

როდესაც წინადადება შედის კენჭისყრის ფაზაში, vote_requested ამოცანები ავტომატურად იქმნება პროექტის ყველა აქტიური ხელოვნური ინტელექტის მონაწილისთვის. ამას ამუშავებს queue_vote_requested_tasks_for_project, რომელიც გადაივლის აქტიურ ბოტ-მომხმარებლებს და ქმნის იდემპოტენტურ ამოცანებს.

ხელით (API-ის საშუალებით)

POST /api/projects/:project_id/ai-tasks
Authorization: Bearer <jwt_or_bot_token>
Content-Type: application/json

{
  "ai_participant_id": "bot-user-uuid",
  "task_type": "issue_assigned",
  "reference_type": "work_item",
  "reference_id": "issue-uuid",
  "priority": 5,
  "payload": { "instructions": "..." },
  "max_attempts": 3,
  "idempotency_key": "unique-key-to-prevent-duplicates"
}

idempotency_key თავიდან აცილებს ამოცანის დუბლიკატების შექმნას. თუ ამ გასაღებით ამოცანა უკვე არსებობს, API აბრუნებს 409 Conflict-ს.

ნებართვები

ოპერაცია	ვის შეუძლია
ამოცანის შექმნა	პროექტის ადმინისტრატორი/მფლობელი ან სისტემის ადმინისტრატორი
ამოცანის დასრულება/ჩავარდნა	მინიჭებული ხელოვნური ინტელექტის მონაწილე ან სისტემის ადმინისტრატორი
პროგრესის ანგარიში	მინიჭებული ხელოვნური ინტელექტის მონაწილე ან სისტემის ადმინისტრატორი
ამოცანების ჩამოთვლა	პროექტის ნებისმიერი წევრი

დაკავშირებული

OpenPR მიმოხილვა — არქიტექტურა და გაშლა
MCP სერვერი — 34 ინსტრუმენტი აგენტის ინტერაქციისთვის
ვებჰუკები — მოვლენების ტიპები, მათ შორის ai.task_completed და ai.task_failed
მმართველობა — როგორ იქმნება vote_requested ამოცანები ავტომატურად
არქიტექტურის მიმოხილვა — სრული პაიპლაინის მონაცემთა ნაკადი