ჰუკები

PRX ჰუკები მოვლენებით მართულ გაფართოების სისტემას უზრუნველყოფს, რომელიც აგენტის შესრულების დროს სასიცოცხლო ციკლის მოვლენებზე რეაგირების საშუალებას იძლევა. აგენტის ციკლის ყოველი მნიშვნელოვანი მომენტი -- ბიჯის დაწყება, LLM-ის გამოძახება, ინსტრუმენტის გაშვება, შეცდომის დაფიქსირება -- ჰუკის მოვლენას ასხივებს. მოვლენებზე მოქმედებები hooks.json კონფიგურაციის ფაილით, WASM პლაგინის მანიფესტებით ან HTTP API-ით მიმაგრდება.

ჰუკები ცეცხლი-და-დავიწყება (fire-and-forget) პრინციპით მუშაობს. ისინი არასდროს ბლოკავს აგენტის ციკლს, არასდროს ცვლის შესრულების ნაკადს და არასდროს აბრუნებს მონაცემებს საუბარში. ეს მათ იდეალურს ხდის აუდიტის ჟურნალისთვის, მეტრიკების შეგროვებისთვის, გარე შეტყობინებებისთვის და გვერდითი ეფექტების ავტომატიზაციისთვის -- ბირთვულ აგენტის პაიპლაინში ლატენტურობის ან მარცხის რეჟიმების შეტანის გარეშე.

სამი ჰუკის შესრულების ბექენდი არსებობს:

Shell ჰუკები -- გარე ბრძანების შესრულება მოვლენის დატვირთვით, რომელიც გარემოს ცვლადით, დროებითი ფაილით ან stdin-ით გადაეცემა. კონფიგურირდება hooks.json-ში.
WASM პლაგინის ჰუკები -- WASM პლაგინის მიერ ექსპორტირებული on-event ფუნქციის გამოძახება. განსაზღვრულია პლაგინის plugin.toml მანიფესტში.
მოვლენების ავტობუსის ჰუკები -- შიდა მოვლენების ავტობუსზე გამოქვეყნება თემაზე prx.lifecycle.<event>. ყოველთვის აქტიურია; კონფიგურაცია არ არის საჭირო.

ჰუკის მოვლენები

PRX 8 სასიცოცხლო ციკლის მოვლენას ასხივებს. თითოეული მოვლენა კონტექსტისთვის სპეციფიკური ველების მქონე JSON დატვირთვას ატარებს.

მოვლენა	როდის ასხივდება	დატვირთვის ველები
`agent_start`	აგენტის ციკლი ახალ ბიჯს იწყებს	`agent` (string), `session` (string)
`agent_end`	აგენტის ციკლი ბიჯს ასრულებს	`success` (bool), `messages_count` (number)
`llm_request`	LLM პროვაიდერზე მოთხოვნის გაგზავნამდე	`provider` (string), `model` (string), `messages_count` (number)
`llm_response`	LLM პასუხის მიღების შემდეგ	`provider` (string), `model` (string), `duration_ms` (number), `success` (bool)
`tool_call_start`	ინსტრუმენტის შესრულების დაწყებამდე	`tool` (string), `arguments` (object)
`tool_call`	ინსტრუმენტის შესრულების დასრულების შემდეგ	`tool` (string), `success` (bool), `output` (string)
`turn_complete`	სრული ბიჯი დასრულდა (ყველა ინსტრუმენტი გადაწყვეტილია)	(ცარიელი ობიექტი)
`error`	შესრულების დროს ნებისმიერი შეცდომა	`component` (string), `message` (string)

დატვირთვის სქემები

ყველა დატვირთვა JSON ობიექტია. ზედა დონის სტრუქტურა მოვლენისთვის სპეციფიკურ ველებს ახვევს:

json

{
  "event": "llm_response",
  "timestamp": "2026-03-21T08:15:30.123Z",
  "session_id": "sess_abc123",
  "payload": {
    "provider": "openai",
    "model": "gpt-4o",
    "duration_ms": 1842,
    "success": true
  }
}

event, timestamp და session_id ველები ყოველ ჰუკის მოვლენაში არსებობს. payload ობიექტი მოვლენის ტიპის მიხედვით იცვლება, როგორც ზემოთ ცხრილშია აღწერილი.

კონფიგურაცია

Shell ჰუკები hooks.json ფაილით კონფიგურირდება, რომელიც სამუშაო სივრცის დირექტორიაში (იმავე დირექტორიაში, სადაც config.toml) თავსდება. PRX ამ ფაილს ცვლილებებისთვის აკვირდება და კონფიგურაციას ცხლად ტვირთავს გადატვირთვის საჭიროების გარეშე.

ძირითადი სტრუქტურა

json

{
  "hooks": {
    "<event_name>": [
      {
        "command": "/path/to/script",
        "args": ["--flag", "value"],
        "env": {
          "CUSTOM_VAR": "value"
        },
        "cwd": "/working/directory",
        "timeout_ms": 5000,
        "stdin_json": true
      }
    ]
  }
}

თითოეული მოვლენის სახელი ჰუკის მოქმედებების მასივზე შეესაბამება. ერთ მოვლენაზე მრავალი მოქმედება შეიძლება მიმაგრდეს; ისინი ერთდროულად და დამოუკიდებლად სრულდება.

სრული მაგალითი

json

{
  "hooks": {
    "agent_start": [
      {
        "command": "/usr/local/bin/notify",
        "args": ["--channel", "ops", "--title", "Agent Started"],
        "timeout_ms": 3000
      }
    ],
    "llm_response": [
      {
        "command": "python3",
        "args": ["/opt/hooks/log_latency.py"],
        "stdin_json": true,
        "timeout_ms": 2000
      }
    ],
    "tool_call": [
      {
        "command": "/opt/hooks/audit_tool_usage.sh",
        "env": {
          "LOG_DIR": "/var/log/prx/audit"
        },
        "timeout_ms": 5000
      }
    ],
    "error": [
      {
        "command": "curl",
        "args": [
          "-X", "POST",
          "-H", "Content-Type: application/json",
          "-d", "@-",
          "https://hooks.slack.com/services/T00/B00/xxxxx"
        ],
        "stdin_json": true,
        "timeout_ms": 10000
      }
    ]
  }
}

ჰუკის მოქმედების ველები

თითოეული ჰუკის მოქმედების ობიექტი შემდეგ ველებს უჭერს მხარს:

ველი	ტიპი	სავალდებულო	ნაგულისხმევი	აღწერა
`command`	string	დიახ	--	შესრულებადი ფაილის აბსოლუტური ბილიკი ან სანიტარიზებულ PATH-ში ნაპოვნი ბრძანების სახელი
`args`	string[]	არა	`[]`	ბრძანებაზე გადაცემული არგუმენტები
`env`	object	არა	`{}`	დამატებითი გარემოს ცვლადები, რომლებიც სანიტარიზებულ შესრულების გარემოში ერწყმება
`cwd`	string	არა	სამუშაო სივრცის დირექტორია	გაშვებული პროცესის სამუშაო დირექტორია
`timeout_ms`	number	არა	`30000`	შესრულების მაქსიმალური დრო მილიწამებში. პროცესი მოკვდება (SIGKILL) ლიმიტის გადაჭარბებისას
`stdin_json`	bool	არა	`false`	`true` შემთხვევაში სრული მოვლენის დატვირთვის JSON stdin-ით მიეწოდება პროცესს

შენიშვნები `command`-ის შესახებ

command ველი შესრულებამდე უსაფრთხოების ვალიდაციას გადის. იგი არ უნდა შეიცავდეს shell-ის მეტასიმბოლოებს (;, |, &, `, $()) -- ისინი shell ინექციის თავიდან ასაცილებლად უარყოფილია. თუ shell-ის ფუნქციები გჭირდებათ, მოათავსეთ ისინი სკრიპტის ფაილში და command ამ სკრიპტზე მიმართეთ.

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

დატვირთვის მიწოდება

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

1. გარემოს ცვლადი (`ZERO_HOOK_PAYLOAD`)

დატვირთვის JSON სტრინგი ZERO_HOOK_PAYLOAD გარემოს ცვლადად დაყენდება. ეს shell სკრიპტებისთვის ყველაზე მარტივი წვდომის მეთოდია:

bash

#!/bin/bash
# დატვირთვის წაკითხვა გარემოს ცვლადიდან
echo "$ZERO_HOOK_PAYLOAD" | jq '.payload.tool'

ზომის ლიმიტი: 8 KB. თუ სერიალიზებული დატვირთვა 8 KB-ს აღემატება, გარემოს ცვლადი არ დაყენდება და დატვირთვა მხოლოდ დროებითი ფაილისა და stdin არხებით იქნება ხელმისაწვდომი.

2. დროებითი ფაილი (`ZERO_HOOK_PAYLOAD_FILE`)

დატვირთვა დროებით ფაილში იწერება, ხოლო ფაილის ბილიკი ZERO_HOOK_PAYLOAD_FILE გარემოს ცვლადში აყენდება. დროებითი ფაილი ჰუკის პროცესის დასრულების შემდეგ ავტომატურად წაიშლება.

python

import os, json

payload_file = os.environ["ZERO_HOOK_PAYLOAD_FILE"]
with open(payload_file) as f:
    data = json.load(f)
print(f"Tool: {data['payload']['tool']}, Success: {data['payload']['success']}")

ამ არხს ზომის ლიმიტი არ აქვს და რეკომენდებულია დატვირთვებისთვის, რომლებიც შესაძლოა დიდი იყოს (მაგ., tool_call ვრცელი გამოსავალით).

3. სტანდარტული შემავალი (stdin)

როდესაც stdin_json true-ზეა დაყენებული ჰუკის მოქმედებაში, დატვირთვის JSON stdin-ით მიეწოდება პროცესს. ეს სასარგებლოა ბრძანებებისთვის, რომლებიც stdin-იდან კითხულობს, მაგალითად curl -d @- ან jq.

bash

#!/bin/bash
# stdin-იდან წაკითხვა (მოითხოვს stdin_json: true ჰუკის კონფიგურაციაში)
read -r payload
echo "$payload" | jq -r '.payload.message'

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

ყოველი ჰუკის პროცესი შემდეგ გარემოს ცვლადებს იღებს, ZERO_HOOK_PAYLOAD და ZERO_HOOK_PAYLOAD_FILE-ის გარდა:

ცვლადი	აღწერა	მაგალითი
`ZERO_HOOK_EVENT`	მოვლენის სახელი, რომელმაც ეს ჰუკი გააქტივა	`tool_call`
`ZERO_HOOK_SESSION`	მიმდინარე სესიის იდენტიფიკატორი	`sess_abc123`
`ZERO_HOOK_TIMESTAMP`	მოვლენის ISO 8601 დროის შტამპი	`2026-03-21T08:15:30.123Z`
`ZERO_HOOK_PAYLOAD`	სრული დატვირთვა JSON სტრინგად (გამოტოვებულია >8 KB შემთხვევაში)	`{"event":"tool_call",...}`
`ZERO_HOOK_PAYLOAD_FILE`	დატვირთვის შემცველი დროებითი ფაილის ბილიკი	`/tmp/prx-hook-a1b2c3.json`

შესრულების გარემო ჰუკის პროცესის დაწყებამდე სანიტარიზებულია. საშიში და სენსიტიური გარემოს ცვლადები ამოიშლება (იხ. უსაფრთხოება ქვემოთ), და მხოლოდ ზემოთ ჩამოთვლილი ცვლადები პლუს ჰუკის მოქმედებიდან env გადაფარვები ხელმისაწვდომია.

WASM პლაგინის ჰუკები

WASM პლაგინებს შეუძლიათ ჰუკის მოვლენებზე გამოწერა PRX WIT (WebAssembly Interface Types) ინტერფეისში განსაზღვრული on-event ფუნქციის ექსპორტით.

WIT ინტერფეისი

wit

interface hooks {
    /// გამოძახდება გამოწერილი მოვლენის გააქტივებისას.
    /// აბრუნებს Ok(()) წარმატებისას, Err(message) მარცხისას.
    on-event: func(event: string, payload-json: string) -> result<_, string>;
}

event პარამეტრი არის მოვლენის სახელი (მაგ., "tool_call"), ხოლო payload-json არის სრული დატვირთვა JSON სტრინგად სერიალიზებული, იდენტური იმისა, რასაც shell ჰუკები იღებს.

მოვლენებზე გამოწერის შაბლონები

პლაგინები აცხადებს რომელი მოვლენების მიღება სურთ plugin.toml მანიფესტში შაბლონის შედარების გამოყენებით:

შაბლონი	ემთხვევა	მაგალითი
ზუსტი შესაბამისობა	ერთ კონკრეტულ მოვლენას	`"tool_call"`
ბადალი სუფიქსი	პრეფიქსთან შესაბამისი ყველა მოვლენა	`"prx.lifecycle.*"`
უნივერსალური	ყველა მოვლენა	`"*"`

პლაგინის მანიფესტის მაგალითი

toml

[plugin]
name = "audit-logger"
version = "0.1.0"
description = "Logs all lifecycle events to an audit trail"

[[capabilities]]
type = "hook"
events = ["agent_start", "agent_end", "error"]

[[capabilities]]
type = "hook"
events = ["prx.lifecycle.*"]

ერთ პლაგინს შეუძლია მრავალი [[capabilities]] ბლოკი სხვადასხვა მოვლენის შაბლონებით განაცხადოს. ყველა შესაბამისი მოვლენის კავშირი განსაზღვრავს რომელ მოვლენებს მიიღებს პლაგინი.

შესრულების მოდელი

WASM პლაგინის ჰუკები WASM სენდბოქსში მუშაობს პლაგინის სხვა ფუნქციების იგივე რესურსების ლიმიტებით. მათზე ვრცელდება:

მეხსიერების ლიმიტი: განსაზღვრული პლაგინის რესურსების კონფიგურაციაში (ნაგულისხმევი 64 MB)
შესრულების დროის ამოწურვა: იგივე, რაც shell ჰუკებისთვის timeout_ms (ნაგულისხმევი 30 წამი)
ფაილური სისტემის წვდომა არ აქვს: თუ WASI შესაძლებლობებით ექსპლიციტურად არ არის მინიჭებული
ქსელური წვდომა არ აქვს: თუ შესაძლებლობების ფლაგებით ექსპლიციტურად არ არის მინიჭებული

თუ WASM ჰუკი Err(message)-ს აბრუნებს, შეცდომა ჟურნალში აღირიცხება, მაგრამ აგენტის ციკლს არ ეხება. ჰუკები ყოველთვის ცეცხლი-და-დავიწყების პრინციპით მუშაობს.

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

ყოველი ჰუკის მოვლენა ავტომატურად ქვეყნდება შიდა მოვლენების ავტობუსზე თემაზე prx.lifecycle.<event>. ეს ხდება მიუხედავად იმისა, კონფიგურირებულია თუ არა shell ან WASM ჰუკები.

თემის ფორმატი

prx.lifecycle.agent_start
prx.lifecycle.agent_end
prx.lifecycle.llm_request
prx.lifecycle.llm_response
prx.lifecycle.tool_call_start
prx.lifecycle.tool_call
prx.lifecycle.turn_complete
prx.lifecycle.error

გამოწერის ტიპები

შიდა კომპონენტებსა და პლაგინებს შეუძლიათ მოვლენების ავტობუსის თემებზე სამი შაბლონით გამოწერა:

ზუსტი: prx.lifecycle.tool_call -- მხოლოდ tool_call მოვლენებს იღებს
ბადალი: prx.lifecycle.* -- ყველა სასიცოცხლო ციკლის მოვლენას იღებს
იერარქიული: prx.* -- ყველა PRX დომენის მოვლენას იღებს (სასიცოცხლო ციკლი, მეტრიკები და სხვ.)

დატვირთვის ლიმიტები

შეზღუდვა	მნიშვნელობა
დატვირთვის მაქსიმალური ზომა	64 KB
რეკურსიის მაქსიმალური სიღრმე	8 დონე
გადაცემის მოდელი	ცეცხლი-და-დავიწყება (ასინქრონული)
მიწოდების გარანტია	მაქსიმუმ-ერთხელ

თუ ჰუკის მოვლენა სხვა ჰუკის მოვლენას გააქტივებს (მაგ., ჰუკის სკრიპტი ინსტრუმენტს გამოიძახებს, რომელიც tool_call-ს ასხივებს), რეკურსიის მთვლელი იზრდება. 8 დონის სიღრმეზე შემდგომი მოვლენების ასხივება უხმოდ წყდება უსასრულო ციკლების თავიდან ასაცილებლად.

HTTP API

ჰუკები პროგრამულად შეიძლება იმართოს HTTP API-ით. ყველა ენდფოინთი ავთენტიფიკაციას მოითხოვს და JSON პასუხებს აბრუნებს.

ყველა ჰუკის სია

GET /api/hooks

პასუხი:

json

{
  "hooks": [
    {
      "id": "hook_01",
      "event": "error",
      "action": {
        "command": "/opt/hooks/notify_error.sh",
        "args": [],
        "timeout_ms": 5000,
        "stdin_json": false
      },
      "enabled": true,
      "created_at": "2026-03-20T10:00:00Z",
      "updated_at": "2026-03-20T10:00:00Z"
    }
  ]
}

ჰუკის შექმნა

POST /api/hooks
Content-Type: application/json

{
  "event": "llm_response",
  "action": {
    "command": "python3",
    "args": ["/opt/hooks/track_latency.py"],
    "stdin_json": true,
    "timeout_ms": 3000
  },
  "enabled": true
}

პასუხი (201 Created):

json

{
  "id": "hook_02",
  "event": "llm_response",
  "action": {
    "command": "python3",
    "args": ["/opt/hooks/track_latency.py"],
    "stdin_json": true,
    "timeout_ms": 3000
  },
  "enabled": true,
  "created_at": "2026-03-21T08:00:00Z",
  "updated_at": "2026-03-21T08:00:00Z"
}

ჰუკის განახლება

PUT /api/hooks/hook_02
Content-Type: application/json

{
  "event": "llm_response",
  "action": {
    "command": "python3",
    "args": ["/opt/hooks/track_latency_v2.py"],
    "stdin_json": true,
    "timeout_ms": 5000
  },
  "enabled": true
}

პასუხი (200 OK): აბრუნებს განახლებულ ჰუკის ობიექტს.

ჰუკის წაშლა

DELETE /api/hooks/hook_02

პასუხი (204 No Content): წარმატებისას ცარიელი სხეული.

ჰუკის გადართვა

PATCH /api/hooks/hook_01/toggle

პასუხი (200 OK):

json

{
  "id": "hook_01",
  "enabled": false
}

ეს ენდფოინთი enabled მდგომარეობას ცვლის. გამორთული ჰუკები კონფიგურაციაში რჩება, მაგრამ მათი მოვლენის გააქტივებისას არ სრულდება.

უსაფრთხოება

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

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

შემდეგი გარემოს ცვლადები ჰუკის შესრულების გარემოდან ამოიშლება და ჰუკის მოქმედებაში env ველით ვერ გადაიფარება:

ცვლადი	მიზეზი
`LD_PRELOAD`	ბიბლიოთეკის ინექციის თავდასხმის ვექტორი
`LD_LIBRARY_PATH`	ბიბლიოთეკის ძიების ბილიკის მანიპულაცია
`DYLD_INSERT_LIBRARIES`	macOS ბიბლიოთეკის ინექცია
`DYLD_LIBRARY_PATH`	macOS ბიბლიოთეკის ბილიკის მანიპულაცია
`PATH`	PATH-ის გატაცების თავიდან აცილება; მინიმალური უსაფრთხო PATH მიეწოდება
`HOME`	სახლის დირექტორიის გაყალბების თავიდან აცილება

შემავალი მონაცემების ვალიდაცია

ნულოვანი ბაიტის უარყოფა: ნებისმიერი command, args, env გასაღები ან env მნიშვნელობა, რომელიც ნულოვან ბაიტს (\0) შეიცავს, უარყოფილია. ეს თავიდან იცილებს ნულოვანი ბაიტის ინექციის თავდასხმებს, რომლებმაც შეიძლება სტრინგები OS დონეზე შეამოკლოს.
Shell მეტასიმბოლოების უარყოფა: command ველი არ უნდა შეიცავდეს ;, |, &, `, $( ან სხვა shell მეტასიმბოლოებს. ეს shell ინექციას თავიდან იცილებს, თუნდაც ბრძანება შემთხვევით shell-ში გადავიდეს.
ბილიკის გადაცილება: cwd ველი ვალიდაცია, რომ .. კომპონენტებით სამუშაო სივრცის დირექტორიის მიღმა არ გავიდეს.

დროის ამოწურვის აღსრულება

ყოველი ჰუკის პროცესი კონფიგურირებულ timeout_ms-ს ექვემდებარება (ნაგულისხმევი 30 წამი). თუ პროცესი ამ ლიმიტს გადააჭარბებს:

SIGTERM იგზავნება პროცესზე
5-წამიანი საშეღავათო პერიოდის შემდეგ SIGKILL იგზავნება
ჰუკი შიდა მეტრიკებში დროის ამოწურვით აღინიშნება
აგენტის ციკლს არ ეხება

რესურსის იზოლაცია

ჰუკის პროცესები shell ინსტრუმენტის შესრულებების იგივე cgroup და namespace შეზღუდვებს მემკვიდრეობით იღებს, როდესაც სენდბოქსის ბექენდი აქტიურია. Docker სენდბოქსის რეჟიმში ჰუკები ცალკე კონტეინერში მუშაობს ნაგულისხმევად ქსელის წვდომის გარეშე.

მაგალითები

აუდიტის ჟურნალის ჰუკი

ყოველი ინსტრუმენტის გამოძახების ჟურნალი ფაილში შესაბამისობის აუდიტისთვის:

json

{
  "hooks": {
    "tool_call": [
      {
        "command": "/opt/hooks/audit_log.sh",
        "env": {
          "AUDIT_LOG": "/var/log/prx/tool_audit.jsonl"
        },
        "timeout_ms": 2000
      }
    ]
  }
}

/opt/hooks/audit_log.sh:

bash

#!/bin/bash
echo "$ZERO_HOOK_PAYLOAD" >> "$AUDIT_LOG"

შეცდომის შეტყობინების ჰუკი

შეცდომის მოვლენების Slack არხზე გაგზავნა:

json

{
  "hooks": {
    "error": [
      {
        "command": "curl",
        "args": [
          "-s", "-X", "POST",
          "-H", "Content-Type: application/json",
          "-d", "@-",
          "https://hooks.slack.com/services/T00/B00/xxxxx"
        ],
        "stdin_json": true,
        "timeout_ms": 10000
      }
    ]
  }
}

LLM ლატენტურობის მეტრიკების ჰუკი

LLM პასუხის დროის თვალყურის დევნება მონიტორინგის დაფებისთვის:

json

{
  "hooks": {
    "llm_response": [
      {
        "command": "python3",
        "args": ["/opt/hooks/metrics.py"],
        "stdin_json": true,
        "timeout_ms": 3000
      }
    ]
  }
}

/opt/hooks/metrics.py:

python

import sys, json

data = json.load(sys.stdin)
payload = data["payload"]
provider = payload["provider"]
model = payload["model"]
duration = payload["duration_ms"]
success = payload["success"]

# StatsD, Prometheus pushgateway ან ნებისმიერ მეტრიკების ბექენდზე გაგზავნა
print(f"prx.llm.duration,provider={provider},model={model} {duration}")
print(f"prx.llm.success,provider={provider},model={model} {1 if success else 0}")

სესიის სასიცოცხლო ციკლის თვალყურის დევნება

აგენტის სესიის დაწყებისა და დასრულების თვალყურის დევნება გამოყენების ანალიტიკისთვის:

json

{
  "hooks": {
    "agent_start": [
      {
        "command": "/opt/hooks/session_tracker.sh",
        "args": ["start"],
        "timeout_ms": 2000
      }
    ],
    "agent_end": [
      {
        "command": "/opt/hooks/session_tracker.sh",
        "args": ["end"],
        "timeout_ms": 2000
      }
    ]
  }
}

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

Shell-ის შესრულება -- Shell ინსტრუმენტი, რომელსაც ჰუკები ხშირად ახვევს
MCP ინტეგრაცია -- გარე ინსტრუმენტის პროტოკოლი, რომელიც tool_call მოვლენებს ასხივებს
პლაგინები -- WASM პლაგინის სისტემა ჰუკის შესაძლებლობების ჩათვლით
დაკვირვება -- მეტრიკები და ტრეისინგი, რომლებიც ჰუკებს ავსებს
უსაფრთხოება -- სენდბოქსი და პოლიტიკის ძრავი, რომელიც ჰუკის შესრულებას მართავს

ჰუკები ​

ჰუკის მოვლენები ​

დატვირთვის სქემები ​

კონფიგურაცია ​

ძირითადი სტრუქტურა ​

სრული მაგალითი ​

ჰუკის მოქმედების ველები ​

შენიშვნები command-ის შესახებ ​

დატვირთვის მიწოდება ​

1. გარემოს ცვლადი (ZERO_HOOK_PAYLOAD) ​

2. დროებითი ფაილი (ZERO_HOOK_PAYLOAD_FILE) ​

3. სტანდარტული შემავალი (stdin) ​

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

WASM პლაგინის ჰუკები ​

WIT ინტერფეისი ​

მოვლენებზე გამოწერის შაბლონები ​

პლაგინის მანიფესტის მაგალითი ​

შესრულების მოდელი ​

მოვლენების ავტობუსის ინტეგრაცია ​

თემის ფორმატი ​

გამოწერის ტიპები ​

დატვირთვის ლიმიტები ​

HTTP API ​

ყველა ჰუკის სია ​

ჰუკის შექმნა ​

ჰუკის განახლება ​

ჰუკის წაშლა ​

ჰუკის გადართვა ​

უსაფრთხოება ​

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

შემავალი მონაცემების ვალიდაცია ​

დროის ამოწურვის აღსრულება ​

რესურსის იზოლაცია ​

მაგალითები ​

აუდიტის ჟურნალის ჰუკი ​

შეცდომის შეტყობინების ჰუკი ​

LLM ლატენტურობის მეტრიკების ჰუკი ​

სესიის სასიცოცხლო ციკლის თვალყურის დევნება ​

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

ჰუკები

ჰუკის მოვლენები

დატვირთვის სქემები

კონფიგურაცია

ძირითადი სტრუქტურა

სრული მაგალითი

ჰუკის მოქმედების ველები

შენიშვნები `command`-ის შესახებ

დატვირთვის მიწოდება

1. გარემოს ცვლადი (`ZERO_HOOK_PAYLOAD`)

2. დროებითი ფაილი (`ZERO_HOOK_PAYLOAD_FILE`)

3. სტანდარტული შემავალი (stdin)

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

WASM პლაგინის ჰუკები

WIT ინტერფეისი

მოვლენებზე გამოწერის შაბლონები

პლაგინის მანიფესტის მაგალითი

შესრულების მოდელი

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

თემის ფორმატი

გამოწერის ტიპები

დატვირთვის ლიმიტები

HTTP API

ყველა ჰუკის სია

ჰუკის შექმნა

ჰუკის განახლება

ჰუკის წაშლა

ჰუკის გადართვა

უსაფრთხოება

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

შემავალი მონაცემების ვალიდაცია

დროის ამოწურვის აღსრულება

რესურსის იზოლაცია

მაგალითები

აუდიტის ჟურნალის ჰუკი

შეცდომის შეტყობინების ჰუკი

LLM ლატენტურობის მეტრიკების ჰუკი

სესიის სასიცოცხლო ციკლის თვალყურის დევნება

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