Обновить зависимости проекта

.gitea/workflows/ci.yml

@@ -22,6 +22,23 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v5
 
+      - name: Use preinstalled Rust toolchain
+        run: |
+          set -eu
+          toolchain_dir="${RUSTUP_HOME:-$HOME/.rustup}/toolchains/1.96.1-x86_64-unknown-linux-gnu"
+          toolchain_bin="$toolchain_dir/bin"
+          if [ ! -x "$toolchain_bin/rustc" ] || [ ! -x "$toolchain_bin/cargo" ]; then
+            echo "Rust 1.96.1 is not preinstalled at $toolchain_dir." >&2
+            echo "Install it in the Gitea runner image/host before running CI:" >&2
+            echo "rustup toolchain install 1.96.1 --profile minimal --component clippy --component rustfmt" >&2
+            exit 1
+          fi
+          printf '%s\n' "$toolchain_bin" >> "$GITHUB_PATH"
+          "$toolchain_bin/rustc" --version
+          "$toolchain_bin/cargo" --version
+          "$toolchain_bin/rustfmt" --version
+          "$toolchain_bin/cargo-clippy" --version
+
       - name: Verify runner toolchain
         run: |
           python3 --version
@@ -104,6 +121,23 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v5
 
+      - name: Use preinstalled Rust toolchain
+        run: |
+          set -eu
+          toolchain_dir="${RUSTUP_HOME:-$HOME/.rustup}/toolchains/1.96.1-x86_64-unknown-linux-gnu"
+          toolchain_bin="$toolchain_dir/bin"
+          if [ ! -x "$toolchain_bin/rustc" ] || [ ! -x "$toolchain_bin/cargo" ]; then
+            echo "Rust 1.96.1 is not preinstalled at $toolchain_dir." >&2
+            echo "Install it in the Gitea runner image/host before running CI:" >&2
+            echo "rustup toolchain install 1.96.1 --profile minimal --component clippy --component rustfmt" >&2
+            exit 1
+          fi
+          printf '%s\n' "$toolchain_bin" >> "$GITHUB_PATH"
+          "$toolchain_bin/rustc" --version
+          "$toolchain_bin/cargo" --version
+          "$toolchain_bin/rustfmt" --version
+          "$toolchain_bin/cargo-clippy" --version
+
       - name: Verify runner toolchain
         run: |
           rustc --version
@@ -143,3 +177,238 @@ jobs:
 
       - name: Validate Community deployment manifest
         run: docker compose -f deploy/community/docker-compose.yml --env-file deploy/community/.env.example config -q
+
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    needs:
+      - rust
+      - ui
+      - frontend-e2e
+      - deployment
+    if: ${{ gitea.event_name == 'push' && gitea.ref == 'refs/heads/main' }}
+    env:
+      REGISTRY: git.itexp.me
+      IMAGE_TAG: ${{ gitea.sha }}
+      ADMIN_API_IMAGE: git.itexp.me/bsodfather/crank-community-admin-api
+      MCP_SERVER_IMAGE: git.itexp.me/bsodfather/crank-community-mcp-server
+      UI_IMAGE: git.itexp.me/bsodfather/crank-community-ui
+      OPENBAO_ENV_FILE: .openbao-env
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Verify runner toolchain
+        run: |
+          docker --version
+          command -v bao
+          bao version
+
+      - name: Load deployment secrets from OpenBao
+        env:
+          BAO_ADDR: ${{ secrets.BAO_ADDR }}
+          BAO_ROLE_ID: ${{ secrets.BAO_ROLE_ID }}
+          BAO_SECRET_ID: ${{ secrets.BAO_SECRET_ID }}
+          OPENBAO_APP: crank
+        run: scripts/load-openbao-env.sh
+
+      - name: Login to registry
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          printf '%s' "$DEPLOY_REGISTRY_TOKEN" | \
+            docker login '${{ env.REGISTRY }}' -u "$DEPLOY_REGISTRY_USER" --password-stdin
+
+      - name: Build and push images
+        run: |
+          docker build -f apps/admin-api/Dockerfile \
+            -t '${{ env.ADMIN_API_IMAGE }}:${{ env.IMAGE_TAG }}' \
+            -t '${{ env.ADMIN_API_IMAGE }}:main' \
+            .
+          docker build -f apps/mcp-server/Dockerfile \
+            -t '${{ env.MCP_SERVER_IMAGE }}:${{ env.IMAGE_TAG }}' \
+            -t '${{ env.MCP_SERVER_IMAGE }}:main' \
+            .
+          docker build -f apps/ui/Dockerfile \
+            -t '${{ env.UI_IMAGE }}:${{ env.IMAGE_TAG }}' \
+            -t '${{ env.UI_IMAGE }}:main' \
+            .
+          docker push '${{ env.ADMIN_API_IMAGE }}:${{ env.IMAGE_TAG }}'
+          docker push '${{ env.ADMIN_API_IMAGE }}:main'
+          docker push '${{ env.MCP_SERVER_IMAGE }}:${{ env.IMAGE_TAG }}'
+          docker push '${{ env.MCP_SERVER_IMAGE }}:main'
+          docker push '${{ env.UI_IMAGE }}:${{ env.IMAGE_TAG }}'
+          docker push '${{ env.UI_IMAGE }}:main'
+
+      - name: Configure SSH key
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          mkdir -p ~/.ssh
+          chmod 700 ~/.ssh
+          printf '%s\n' "$DEPLOY_SSH_KEY" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+
+      - name: Configure known hosts
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          if [ -n "${DEPLOY_KNOWN_HOSTS:-}" ]; then
+            printf '%s\n' "$DEPLOY_KNOWN_HOSTS" > ~/.ssh/known_hosts
+          else
+            ssh-keyscan -p "${DEPLOY_PORT:-22}" "$DEPLOY_HOST" > ~/.ssh/known_hosts
+          fi
+          chmod 644 ~/.ssh/known_hosts
+
+      - name: Sync deployment files to server
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" \
+            "mkdir -p '$DEPLOY_PATH'"
+          rsync -az -e "ssh -p $DEPLOY_PORT" deploy/community/docker-compose.yml \
+            "$DEPLOY_USER@$DEPLOY_HOST:$DEPLOY_PATH/docker-compose.yml"
+
+      - name: Write environment file
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          tmp_env="$(mktemp)"
+          append_if_set() {
+            if [ -n "$2" ]; then
+              printf '%s=%s\n' "$1" "$2" >> "$tmp_env"
+            fi
+          }
+          : > "$tmp_env"
+          append_if_set POSTGRES_DB "$POSTGRES_DB"
+          append_if_set POSTGRES_USER "$POSTGRES_USER"
+          append_if_set POSTGRES_PASSWORD "$POSTGRES_PASSWORD"
+          append_if_set POSTGRES_HOST "$POSTGRES_HOST"
+          if [ -n "${POSTGRES_PORT:-}" ]; then
+            append_if_set POSTGRES_PORT "$POSTGRES_PORT"
+          elif [ -n "${PGBOUNCER_PORT:-}" ]; then
+            append_if_set POSTGRES_PORT "$PGBOUNCER_PORT"
+          fi
+          append_if_set CRANK_STORAGE_ROOT "$CRANK_STORAGE_ROOT"
+          append_if_set CRANK_PUBLISH_BIND "$CRANK_PUBLISH_BIND"
+          append_if_set CRANK_ADMIN_BIND "$CRANK_ADMIN_BIND"
+          append_if_set CRANK_MCP_BIND "$CRANK_MCP_BIND"
+          append_if_set CRANK_MCP_REFRESH_MS "$CRANK_MCP_REFRESH_MS"
+          append_if_set CRANK_LOG_LEVEL "$CRANK_LOG_LEVEL"
+          append_if_set CRANK_MASTER_KEY "$CRANK_MASTER_KEY"
+          append_if_set CRANK_BASE_URL "$CRANK_BASE_URL"
+          append_if_set CRANK_CACHE_BACKEND "$CRANK_CACHE_BACKEND"
+          append_if_set CRANK_CACHE_URL "$CRANK_CACHE_URL"
+          append_if_set CRANK_CACHE_DEFAULT_TTL_MS "$CRANK_CACHE_DEFAULT_TTL_MS"
+          append_if_set CRANK_SESSION_SECRET "$CRANK_SESSION_SECRET"
+          append_if_set CRANK_PASSWORD_PEPPER "$CRANK_PASSWORD_PEPPER"
+          append_if_set CRANK_SESSION_TTL_HOURS "$CRANK_SESSION_TTL_HOURS"
+          append_if_set CRANK_BOOTSTRAP_ADMIN_EMAIL "$CRANK_BOOTSTRAP_ADMIN_EMAIL"
+          append_if_set CRANK_BOOTSTRAP_ADMIN_PASSWORD "$CRANK_BOOTSTRAP_ADMIN_PASSWORD"
+          append_if_set CRANK_BOOTSTRAP_ADMIN_DISPLAY_NAME "$CRANK_BOOTSTRAP_ADMIN_DISPLAY_NAME"
+          append_if_set CRANK_DEMO_SEED "$CRANK_DEMO_SEED"
+          {
+            printf 'COMPOSE_PROJECT_NAME=community\n'
+            printf 'CRANK_ADMIN_API_IMAGE=%s:%s\n' '${{ env.ADMIN_API_IMAGE }}' '${{ env.IMAGE_TAG }}'
+            printf 'CRANK_MCP_SERVER_IMAGE=%s:%s\n' '${{ env.MCP_SERVER_IMAGE }}' '${{ env.IMAGE_TAG }}'
+            printf 'CRANK_UI_IMAGE=%s:%s\n' '${{ env.UI_IMAGE }}' '${{ env.IMAGE_TAG }}'
+          } >> "$tmp_env"
+          cat "$tmp_env" | ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" \
+            "mkdir -p '$DEPLOY_PATH' && cat > '$DEPLOY_PATH/.env'"
+          rm -f "$tmp_env"
+
+      - name: Validate required environment variables
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" "
+            set -e
+            cd '$DEPLOY_PATH'
+            required_vars='
+              POSTGRES_HOST
+              POSTGRES_PORT
+              POSTGRES_DB
+              POSTGRES_USER
+              POSTGRES_PASSWORD
+              CRANK_MASTER_KEY
+              CRANK_SESSION_SECRET
+              CRANK_PASSWORD_PEPPER
+              CRANK_BOOTSTRAP_ADMIN_EMAIL
+              CRANK_BOOTSTRAP_ADMIN_PASSWORD
+              CRANK_BASE_URL
+            '
+            for var in \$required_vars; do
+              value=\$(grep -E \"^\${var}=\" .env | tail -n1 | cut -d= -f2- || true)
+              if [ -z \"\$value\" ]; then
+                echo \"missing required env: \$var\" >&2
+                exit 1
+              fi
+            done
+          "
+
+      - name: Deploy with Docker Compose
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" "
+            set -e
+            cd '$DEPLOY_PATH'
+            compose_profiles=''
+            cache_backend=\$(grep -E '^CRANK_CACHE_BACKEND=' .env | tail -n1 | cut -d= -f2- || true)
+            if [ \"\$cache_backend\" = 'valkey' ] || [ \"\$cache_backend\" = 'redis' ]; then
+              compose_profiles='--profile cache'
+            fi
+            echo '$DEPLOY_REGISTRY_TOKEN' | docker login '${{ env.REGISTRY }}' -u '$DEPLOY_REGISTRY_USER' --password-stdin
+            docker compose \$compose_profiles config -q
+            docker compose \$compose_profiles pull
+            docker compose \$compose_profiles down --remove-orphans
+            for container in \
+              crank-ui-1 \
+              crank-admin-api-1 \
+              crank-mcp-server-1 \
+              crank-postgres-1 \
+              crank-valkey-1 \
+              crank-community-ui-1 \
+              crank-community-admin-api-1 \
+              crank-community-mcp-server-1 \
+              crank-community-postgres-1 \
+              crank-community-valkey-1; do
+              if docker ps -a --format '{{.Names}}' | grep -Fx \"\$container\" >/dev/null; then
+                docker rm -f \"\$container\"
+              fi
+            done
+            echo 'Docker containers before freeing required ports:'
+            docker ps --format 'table {{.ID}}\t{{.Names}}\t{{.Ports}}'
+            for port in 3000 3001 3002; do
+              container_ids=\$(docker ps -aq --filter \"publish=\$port\")
+              if [ -n \"\$container_ids\" ]; then
+                echo \"Removing containers publishing port \$port\"
+                docker inspect --format '{{.Name}} {{json .NetworkSettings.Ports}}' \$container_ids || true
+                docker rm -f \$container_ids
+              fi
+            done
+            if command -v ss >/dev/null 2>&1; then
+              ss -ltnp '( sport = :3000 or sport = :3001 or sport = :3002 )' || true
+            fi
+            docker compose \$compose_profiles up -d --remove-orphans
+          "
+
+      - name: Verify health endpoints
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" "
+            set -e
+            cd '$DEPLOY_PATH'
+            for attempt in \$(seq 1 30); do
+              if curl --fail --silent http://127.0.0.1:3000/ >/dev/null \
+                && curl --fail --silent http://127.0.0.1:3001/health >/dev/null \
+                && curl --fail --silent http://127.0.0.1:3002/health >/dev/null; then
+                exit 0
+              fi
+              sleep 2
+            done
+            echo 'deployment health verification failed' >&2
+            docker compose ps >&2
+            exit 1
+          "
+
+      - name: Run authenticated product smoke
+        run: |
+          . "$OPENBAO_ENV_FILE"
+          CRANK_STAGING_ADMIN_EMAIL="$CRANK_BOOTSTRAP_ADMIN_EMAIL" \
+          CRANK_STAGING_ADMIN_PASSWORD="$CRANK_BOOTSTRAP_ADMIN_PASSWORD" \
+          scripts/authenticated-product-smoke.sh "$CRANK_BASE_URL"

.gitea/workflows/deploy.yml

@@ -1,237 +0,0 @@
-name: Deploy
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-env:
-  REGISTRY: git.itexp.me
-  IMAGE_TAG: ${{ gitea.sha }}
-  ADMIN_API_IMAGE: git.itexp.me/bsodfather/crank-community-admin-api
-  MCP_SERVER_IMAGE: git.itexp.me/bsodfather/crank-community-mcp-server
-  UI_IMAGE: git.itexp.me/bsodfather/crank-community-ui
-  OPENBAO_ENV_FILE: .openbao-env
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Verify runner toolchain
-        run: |
-          docker --version
-          command -v bao
-          bao version
-
-      - name: Load deployment secrets from OpenBao
-        env:
-          BAO_ADDR: ${{ secrets.BAO_ADDR }}
-          BAO_ROLE_ID: ${{ secrets.BAO_ROLE_ID }}
-          BAO_SECRET_ID: ${{ secrets.BAO_SECRET_ID }}
-          OPENBAO_APP: crank
-        run: scripts/load-openbao-env.sh
-
-      - name: Login to registry
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          printf '%s' "$DEPLOY_REGISTRY_TOKEN" | \
-            docker login '${{ env.REGISTRY }}' -u "$DEPLOY_REGISTRY_USER" --password-stdin
-
-      - name: Build and push images
-        run: |
-          docker build -f apps/admin-api/Dockerfile \
-            -t '${{ env.ADMIN_API_IMAGE }}:${{ env.IMAGE_TAG }}' \
-            -t '${{ env.ADMIN_API_IMAGE }}:main' \
-            .
-          docker build -f apps/mcp-server/Dockerfile \
-            -t '${{ env.MCP_SERVER_IMAGE }}:${{ env.IMAGE_TAG }}' \
-            -t '${{ env.MCP_SERVER_IMAGE }}:main' \
-            .
-          docker build -f apps/ui/Dockerfile \
-            -t '${{ env.UI_IMAGE }}:${{ env.IMAGE_TAG }}' \
-            -t '${{ env.UI_IMAGE }}:main' \
-            .
-          docker push '${{ env.ADMIN_API_IMAGE }}:${{ env.IMAGE_TAG }}'
-          docker push '${{ env.ADMIN_API_IMAGE }}:main'
-          docker push '${{ env.MCP_SERVER_IMAGE }}:${{ env.IMAGE_TAG }}'
-          docker push '${{ env.MCP_SERVER_IMAGE }}:main'
-          docker push '${{ env.UI_IMAGE }}:${{ env.IMAGE_TAG }}'
-          docker push '${{ env.UI_IMAGE }}:main'
-
-      - name: Configure SSH key
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          mkdir -p ~/.ssh
-          chmod 700 ~/.ssh
-          printf '%s\n' "$DEPLOY_SSH_KEY" > ~/.ssh/id_ed25519
-          chmod 600 ~/.ssh/id_ed25519
-
-      - name: Configure known hosts
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          if [ -n "${DEPLOY_KNOWN_HOSTS:-}" ]; then
-            printf '%s\n' "$DEPLOY_KNOWN_HOSTS" > ~/.ssh/known_hosts
-          else
-            ssh-keyscan -p "${DEPLOY_PORT:-22}" "$DEPLOY_HOST" > ~/.ssh/known_hosts
-          fi
-          chmod 644 ~/.ssh/known_hosts
-
-      - name: Sync deployment files to server
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" \
-            "mkdir -p '$DEPLOY_PATH'"
-          rsync -az -e "ssh -p $DEPLOY_PORT" deploy/community/docker-compose.yml \
-            "$DEPLOY_USER@$DEPLOY_HOST:$DEPLOY_PATH/docker-compose.yml"
-
-      - name: Write environment file
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          tmp_env="$(mktemp)"
-          append_if_set() {
-            if [ -n "$2" ]; then
-              printf '%s=%s\n' "$1" "$2" >> "$tmp_env"
-            fi
-          }
-          : > "$tmp_env"
-          append_if_set POSTGRES_DB "$POSTGRES_DB"
-          append_if_set POSTGRES_USER "$POSTGRES_USER"
-          append_if_set POSTGRES_PASSWORD "$POSTGRES_PASSWORD"
-          append_if_set POSTGRES_HOST "$POSTGRES_HOST"
-          if [ -n "${POSTGRES_PORT:-}" ]; then
-            append_if_set POSTGRES_PORT "$POSTGRES_PORT"
-          elif [ -n "${PGBOUNCER_PORT:-}" ]; then
-            append_if_set POSTGRES_PORT "$PGBOUNCER_PORT"
-          fi
-          append_if_set CRANK_STORAGE_ROOT "$CRANK_STORAGE_ROOT"
-          append_if_set CRANK_PUBLISH_BIND "$CRANK_PUBLISH_BIND"
-          append_if_set CRANK_ADMIN_BIND "$CRANK_ADMIN_BIND"
-          append_if_set CRANK_MCP_BIND "$CRANK_MCP_BIND"
-          append_if_set CRANK_MCP_REFRESH_MS "$CRANK_MCP_REFRESH_MS"
-          append_if_set CRANK_LOG_LEVEL "$CRANK_LOG_LEVEL"
-          append_if_set CRANK_MASTER_KEY "$CRANK_MASTER_KEY"
-          append_if_set CRANK_BASE_URL "$CRANK_BASE_URL"
-          append_if_set CRANK_CACHE_BACKEND "$CRANK_CACHE_BACKEND"
-          append_if_set CRANK_CACHE_URL "$CRANK_CACHE_URL"
-          append_if_set CRANK_CACHE_DEFAULT_TTL_MS "$CRANK_CACHE_DEFAULT_TTL_MS"
-          append_if_set CRANK_SESSION_SECRET "$CRANK_SESSION_SECRET"
-          append_if_set CRANK_PASSWORD_PEPPER "$CRANK_PASSWORD_PEPPER"
-          append_if_set CRANK_SESSION_TTL_HOURS "$CRANK_SESSION_TTL_HOURS"
-          append_if_set CRANK_BOOTSTRAP_ADMIN_EMAIL "$CRANK_BOOTSTRAP_ADMIN_EMAIL"
-          append_if_set CRANK_BOOTSTRAP_ADMIN_PASSWORD "$CRANK_BOOTSTRAP_ADMIN_PASSWORD"
-          append_if_set CRANK_BOOTSTRAP_ADMIN_DISPLAY_NAME "$CRANK_BOOTSTRAP_ADMIN_DISPLAY_NAME"
-          append_if_set CRANK_DEMO_SEED "$CRANK_DEMO_SEED"
-          {
-            printf 'COMPOSE_PROJECT_NAME=community\n'
-            printf 'CRANK_ADMIN_API_IMAGE=%s:%s\n' '${{ env.ADMIN_API_IMAGE }}' '${{ env.IMAGE_TAG }}'
-            printf 'CRANK_MCP_SERVER_IMAGE=%s:%s\n' '${{ env.MCP_SERVER_IMAGE }}' '${{ env.IMAGE_TAG }}'
-            printf 'CRANK_UI_IMAGE=%s:%s\n' '${{ env.UI_IMAGE }}' '${{ env.IMAGE_TAG }}'
-          } >> "$tmp_env"
-          cat "$tmp_env" | ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" \
-            "mkdir -p '$DEPLOY_PATH' && cat > '$DEPLOY_PATH/.env'"
-          rm -f "$tmp_env"
-
-      - name: Validate required environment variables
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" "
-            set -e
-            cd '$DEPLOY_PATH'
-            required_vars='
-              POSTGRES_HOST
-              POSTGRES_PORT
-              POSTGRES_DB
-              POSTGRES_USER
-              POSTGRES_PASSWORD
-              CRANK_MASTER_KEY
-              CRANK_SESSION_SECRET
-              CRANK_PASSWORD_PEPPER
-              CRANK_BOOTSTRAP_ADMIN_EMAIL
-              CRANK_BOOTSTRAP_ADMIN_PASSWORD
-              CRANK_BASE_URL
-            '
-            for var in \$required_vars; do
-              value=\$(grep -E \"^\${var}=\" .env | tail -n1 | cut -d= -f2- || true)
-              if [ -z \"\$value\" ]; then
-                echo \"missing required env: \$var\" >&2
-                exit 1
-              fi
-            done
-          "
-
-      - name: Deploy with Docker Compose
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" "
-            set -e
-            cd '$DEPLOY_PATH'
-            compose_profiles=''
-            cache_backend=\$(grep -E '^CRANK_CACHE_BACKEND=' .env | tail -n1 | cut -d= -f2- || true)
-            if [ \"\$cache_backend\" = 'valkey' ] || [ \"\$cache_backend\" = 'redis' ]; then
-              compose_profiles='--profile cache'
-            fi
-            echo '$DEPLOY_REGISTRY_TOKEN' | docker login '${{ env.REGISTRY }}' -u '$DEPLOY_REGISTRY_USER' --password-stdin
-            docker compose \$compose_profiles config -q
-            docker compose \$compose_profiles pull
-            docker compose \$compose_profiles down --remove-orphans
-            for container in \
-              crank-ui-1 \
-              crank-admin-api-1 \
-              crank-mcp-server-1 \
-              crank-postgres-1 \
-              crank-valkey-1 \
-              crank-community-ui-1 \
-              crank-community-admin-api-1 \
-              crank-community-mcp-server-1 \
-              crank-community-postgres-1 \
-              crank-community-valkey-1; do
-              if docker ps -a --format '{{.Names}}' | grep -Fx \"\$container\" >/dev/null; then
-                docker rm -f \"\$container\"
-              fi
-            done
-            echo 'Docker containers before freeing required ports:'
-            docker ps --format 'table {{.ID}}\t{{.Names}}\t{{.Ports}}'
-            for port in 3000 3001 3002; do
-              container_ids=\$(docker ps -aq --filter \"publish=\$port\")
-              if [ -n \"\$container_ids\" ]; then
-                echo \"Removing containers publishing port \$port\"
-                docker inspect --format '{{.Name}} {{json .NetworkSettings.Ports}}' \$container_ids || true
-                docker rm -f \$container_ids
-              fi
-            done
-            if command -v ss >/dev/null 2>&1; then
-              ss -ltnp '( sport = :3000 or sport = :3001 or sport = :3002 )' || true
-            fi
-            docker compose \$compose_profiles up -d --remove-orphans
-          "
-
-      - name: Verify health endpoints
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          ssh -p "$DEPLOY_PORT" "$DEPLOY_USER@$DEPLOY_HOST" "
-            set -e
-            cd '$DEPLOY_PATH'
-            for attempt in \$(seq 1 30); do
-              if curl --fail --silent http://127.0.0.1:3000/ >/dev/null \
-                && curl --fail --silent http://127.0.0.1:3001/health >/dev/null \
-                && curl --fail --silent http://127.0.0.1:3002/health >/dev/null; then
-                exit 0
-              fi
-              sleep 2
-            done
-            echo 'deployment health verification failed' >&2
-            docker compose ps >&2
-            exit 1
-          "
-
-      - name: Run authenticated product smoke
-        run: |
-          . "$OPENBAO_ENV_FILE"
-          CRANK_STAGING_ADMIN_EMAIL="$CRANK_BOOTSTRAP_ADMIN_EMAIL" \
-          CRANK_STAGING_ADMIN_PASSWORD="$CRANK_BOOTSTRAP_ADMIN_PASSWORD" \
-          scripts/authenticated-product-smoke.sh "$CRANK_BASE_URL"

.gitea/workflows/release.yml

@@ -22,6 +22,23 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v5
 
+      - name: Use preinstalled Rust toolchain
+        run: |
+          set -eu
+          toolchain_dir="${RUSTUP_HOME:-$HOME/.rustup}/toolchains/1.96.1-x86_64-unknown-linux-gnu"
+          toolchain_bin="$toolchain_dir/bin"
+          if [ ! -x "$toolchain_bin/rustc" ] || [ ! -x "$toolchain_bin/cargo" ]; then
+            echo "Rust 1.96.1 is not preinstalled at $toolchain_dir." >&2
+            echo "Install it in the Gitea runner image/host before running CI:" >&2
+            echo "rustup toolchain install 1.96.1 --profile minimal --component clippy --component rustfmt" >&2
+            exit 1
+          fi
+          printf '%s\n' "$toolchain_bin" >> "$GITHUB_PATH"
+          "$toolchain_bin/rustc" --version
+          "$toolchain_bin/cargo" --version
+          "$toolchain_bin/rustfmt" --version
+          "$toolchain_bin/cargo-clippy" --version
+
       - name: Verify runner toolchain
         run: |
           rustc --version

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "crates/crank-community-auth",
     "crates/crank-community-mcp",
     "crates/crank-core",
+    "crates/crank-import",
     "crates/crank-schema",
     "crates/crank-mapping",
     "crates/crank-registry",
@@ -17,28 +18,28 @@ resolver = "3"
 [workspace.package]
 edition = "2024"
 license = "AGPL-3.0-only"
-rust-version = "1.85"
+rust-version = "1.96"
 version = "0.3.1"
 
 [workspace.dependencies]
 aes-gcm = "0.10"
 argon2 = "0.5"
 axum = "0.8"
-axum-extra = { version = "0.10", features = ["cookie"] }
+axum-extra = { version = "0.12", features = ["cookie"] }
 base64 = "0.22"
 hkdf = "0.12"
-rand = "0.8"
+rand = "0.10"
 reqwest = { version = "0.12", default-features = false, features = ["cookies", "json", "rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
 sha2 = "0.10"
-sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio-rustls", "postgres", "macros", "json", "time"] }
+sqlx = { version = "0.9", default-features = false, features = ["runtime-tokio", "tls-rustls", "postgres", "macros", "json", "time", "uuid"] }
 thiserror = "2"
-time = { version = "0.3", features = ["formatting", "parsing", "serde"] }
+time = { version = "0.3.53", features = ["formatting", "parsing", "serde"] }
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] }
 uuid = { version = "1", features = ["serde", "v7"] }
-testcontainers = { version = "0.25.0", features = ["blocking"] }
-testcontainers-modules = { version = "0.13.0", features = ["postgres", "blocking"] }
+testcontainers = { version = "0.27", features = ["blocking"] }
+testcontainers-modules = { version = "0.15", features = ["postgres", "blocking"] }

apps/admin-api/Cargo.toml

@@ -16,6 +16,7 @@ axum-extra.workspace = true
 base64.workspace = true
 crank-community-auth = { path = "../../crates/crank-community-auth" }
 crank-core = { path = "../../crates/crank-core" }
+crank-import = { path = "../../crates/crank-import" }
 crank-mapping = { path = "../../crates/crank-mapping" }
 crank-registry = { path = "../../crates/crank-registry" }
 crank-runtime = { path = "../../crates/crank-runtime" }

apps/admin-api/Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.85-bookworm AS deps
+FROM rust:1.96.1-bookworm AS deps
 
 WORKDIR /app
 
@@ -36,7 +36,7 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/app/target \
     SQLX_OFFLINE=true cargo build --release -p admin-api
 
-FROM rust:1.85-bookworm AS builder
+FROM rust:1.96.1-bookworm AS builder
 
 WORKDIR /app
 

apps/admin-api/src/app.rs

@@ -18,7 +18,11 @@ use crate::{
         auth::{change_password, get_profile, get_session, login, logout, update_profile},
         auth_profiles::{create_auth_profile, get_auth_profile, list_auth_profiles},
         capabilities::get_capabilities,
-        observability::{get_agent_usage, get_log, get_operation_usage, get_usage, list_logs},
+        imports::{create_openapi_import, preview_openapi_import},
+        observability::{
+            get_agent_usage, get_approval, get_log, get_operation_usage, get_usage, list_approvals,
+            list_logs,
+        },
         operations::{
             analyze_operation_quality, archive_operation, create_operation, create_version,
             delete_operation, export_operation, generate_draft, get_operation,
@@ -35,6 +39,11 @@ use crate::{
 pub fn build_app(state: AppState) -> Router {
     let workspace_router = Router::new()
         .route("/operations", get(list_operations).post(create_operation))
+        .route("/imports/openapi/preview", post(preview_openapi_import))
+        .route(
+            "/imports/openapi/{job_id}/create",
+            post(create_openapi_import),
+        )
         .route(
             "/operations/analyze-quality",
             post(analyze_operation_quality),
@@ -117,6 +126,8 @@ pub fn build_app(state: AppState) -> Router {
         .route("/export", get(export_workspace))
         .route("/logs", get(list_logs))
         .route("/logs/{log_id}", get(get_log))
+        .route("/approvals", get(list_approvals))
+        .route("/approvals/{approval_id}", get(get_approval))
         .route("/usage", get(get_usage))
         .route("/usage/operations/{operation_id}", get(get_operation_usage))
         .route("/usage/agents/{agent_id}", get(get_agent_usage));

apps/admin-api/src/dto.rs

@@ -1,8 +1,8 @@
 use crank_core::{
-    AgentId, AgentStatus, AuthConfig, AuthKind, ExecutionMode, ExportMode, GeneratedDraft,
-    InvocationLevel, InvocationSource, InvocationStatus, OperationSecurityLevel, OperationStatus,
-    PlatformApiKeyScope, Protocol, SecretKind, Target, UsagePeriod, WizardState, WorkspaceId,
-    WorkspaceStatus,
+    AgentId, AgentStatus, ApprovalRequestStatus, AuthConfig, AuthKind, ExecutionMode, ExportMode,
+    GeneratedDraft, InvocationLevel, InvocationSource, InvocationStatus, OperationSecurityLevel,
+    OperationStatus, PlatformApiKeyKind, PlatformApiKeyScope, Protocol, SecretKind, Target,
+    UsagePeriod, WizardState, WorkspaceId, WorkspaceStatus,
 };
 use crank_mapping::MappingSet;
 use crank_registry::{
@@ -211,7 +211,17 @@ pub struct AgentMutationResult {
 #[derive(Clone, Debug, Deserialize)]
 pub struct PlatformApiKeyPayload {
     pub name: String,
+    #[serde(default = "default_platform_api_key_kind")]
+    pub key_kind: PlatformApiKeyKind,
     pub scopes: Vec<PlatformApiKeyScope>,
+    #[serde(default)]
+    pub expires_at: Option<String>,
+    #[serde(default)]
+    pub allowed_origins: Vec<String>,
+}
+
+fn default_platform_api_key_kind() -> PlatformApiKeyKind {
+    PlatformApiKeyKind::McpClient
 }
 
 #[derive(Clone, Debug, Serialize)]
@@ -240,6 +250,12 @@ pub struct LogsQuery {
     pub limit: Option<u32>,
 }
 
+#[derive(Clone, Debug, Deserialize)]
+pub struct ApprovalsQuery {
+    pub status: Option<ApprovalRequestStatus>,
+    pub limit: Option<u32>,
+}
+
 #[derive(Clone, Debug, Deserialize)]
 pub struct UsageRequestQuery {
     pub period: Option<UsagePeriod>,
@@ -309,6 +325,48 @@ pub struct YamlOperationDocument {
     pub operation: RegistryOperation,
 }
 
+#[derive(Clone, Debug, Deserialize)]
+pub struct OpenApiImportPreviewPayload {
+    pub document: String,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct OpenApiImportPreviewResponse {
+    pub job_id: String,
+    pub expires_at: String,
+    pub preview: crank_import::rest::ImportPreview,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct OpenApiImportCreatePayload {
+    pub selected_operation_keys: Vec<String>,
+    #[serde(default)]
+    pub server_url: Option<String>,
+    #[serde(default = "default_openapi_conflict_mode")]
+    pub conflict_mode: String,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct OpenApiImportCreateResponse {
+    pub created: Vec<OpenApiImportCreatedOperation>,
+    pub skipped: Vec<OpenApiImportSkippedOperation>,
+    pub findings: Vec<crank_import::rest::ImportFinding>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct OpenApiImportCreatedOperation {
+    pub operation_id: String,
+    pub name: String,
+    pub version: u32,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct OpenApiImportSkippedOperation {
+    pub operation_key: String,
+    pub name: String,
+    pub reason: String,
+}
+
 #[derive(Clone, Debug, Serialize)]
 pub struct CreatedOperationResponse {
     pub operation_id: String,
@@ -433,6 +491,10 @@ fn default_operation_category() -> String {
     "general".to_owned()
 }
 
+fn default_openapi_conflict_mode() -> String {
+    "rename".to_owned()
+}
+
 fn default_export_mode() -> ExportMode {
     ExportMode::Portable
 }

apps/admin-api/src/error.rs

@@ -347,6 +347,10 @@ impl From<RegistryError> for ApiError {
                 format!("yaml import job {job_id} was not found"),
                 json!({ "job_id": job_id }),
             ),
+            RegistryError::ImportJobNotFound { job_id } => Self::not_found_with_context(
+                format!("import job {job_id} was not found"),
+                json!({ "job_id": job_id }),
+            ),
             RegistryError::Storage(_) | RegistryError::Serialization(_) => {
                 Self::internal(value.to_string())
             }

apps/admin-api/src/import_guidance.rs

@@ -175,6 +175,7 @@ mod tests {
                 response_cache: None,
                 idempotency: None,
                 safety: None,
+                approval_policy: None,
                 auth_profile_ref: None,
                 headers: BTreeMap::new(),
             },

apps/admin-api/src/routes.rs

@@ -3,6 +3,7 @@ pub mod agents;
 pub mod auth;
 pub mod auth_profiles;
 pub mod capabilities;
+pub mod imports;
 pub mod observability;
 pub mod operations;
 pub mod secrets;

apps/admin-api/src/routes/imports.rs

@@ -0,0 +1,51 @@
+use axum::{
+    Json,
+    extract::{Path, State},
+};
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use crate::{
+    error::ApiError,
+    service::{OpenApiImportCreatePayload, OpenApiImportPreviewPayload},
+    state::AppState,
+};
+
+#[derive(Deserialize)]
+pub struct WorkspacePath {
+    pub workspace_id: String,
+}
+
+#[derive(Deserialize)]
+pub struct WorkspaceImportPath {
+    pub workspace_id: String,
+    pub job_id: String,
+}
+
+pub async fn preview_openapi_import(
+    Path(path): Path<WorkspacePath>,
+    State(state): State<AppState>,
+    Json(payload): Json<OpenApiImportPreviewPayload>,
+) -> Result<Json<Value>, ApiError> {
+    let preview = state
+        .service
+        .preview_openapi_import(&path.workspace_id.as_str().into(), payload)
+        .await?;
+    Ok(Json(json!(preview)))
+}
+
+pub async fn create_openapi_import(
+    Path(path): Path<WorkspaceImportPath>,
+    State(state): State<AppState>,
+    Json(payload): Json<OpenApiImportCreatePayload>,
+) -> Result<Json<Value>, ApiError> {
+    let imported = state
+        .service
+        .create_openapi_import(
+            &path.workspace_id.as_str().into(),
+            &path.job_id.as_str().into(),
+            payload,
+        )
+        .await?;
+    Ok(Json(json!(imported)))
+}

apps/admin-api/src/routes/observability.rs

@@ -7,7 +7,7 @@ use serde_json::{Value, json};
 use crate::{
     error::ApiError,
     routes::access::WorkspacePath,
-    service::{LogsQuery, UsageRequestQuery},
+    service::{ApprovalsQuery, LogsQuery, UsageRequestQuery},
     state::AppState,
 };
 
@@ -17,6 +17,12 @@ pub struct WorkspaceLogPath {
     pub log_id: String,
 }
 
+#[derive(serde::Deserialize)]
+pub struct WorkspaceApprovalPath {
+    pub workspace_id: String,
+    pub approval_id: String,
+}
+
 #[derive(serde::Deserialize)]
 pub struct WorkspaceOperationUsagePath {
     pub workspace_id: String,
@@ -55,6 +61,32 @@ pub async fn get_log(
     Ok(Json(json!(item)))
 }
 
+pub async fn list_approvals(
+    Path(path): Path<WorkspacePath>,
+    Query(query): Query<ApprovalsQuery>,
+    State(state): State<AppState>,
+) -> Result<Json<Value>, ApiError> {
+    let items = state
+        .service
+        .list_approvals(&path.workspace_id.as_str().into(), query)
+        .await?;
+    Ok(Json(json!({ "items": items })))
+}
+
+pub async fn get_approval(
+    Path(path): Path<WorkspaceApprovalPath>,
+    State(state): State<AppState>,
+) -> Result<Json<Value>, ApiError> {
+    let item = state
+        .service
+        .get_approval(
+            &path.workspace_id.as_str().into(),
+            &path.approval_id.as_str().into(),
+        )
+        .await?;
+    Ok(Json(json!(item)))
+}
+
 pub async fn get_usage(
     Path(path): Path<WorkspacePath>,
     Query(query): Query<UsageRequestQuery>,

apps/admin-api/src/service.rs

@@ -27,6 +27,7 @@ mod api_keys;
 mod auth;
 mod demo;
 mod import_export;
+mod imports;
 mod observability;
 mod operation_validation;
 mod operations;
@@ -37,7 +38,8 @@ mod workspaces;
 
 use crate::{auth::AuthSettings, error::ApiError, storage::LocalArtifactStorage};
 use operation_validation::{
-    validate_idempotency_policy, validate_protocol_target, validate_response_cache_policy,
+    validate_approval_policy, validate_idempotency_policy, validate_protocol_target,
+    validate_response_cache_policy,
 };
 
 #[derive(Clone)]
@@ -297,6 +299,7 @@ impl AdminService {
         validate_protocol_target(payload.protocol, &payload.target)?;
         validate_response_cache_policy(&payload.target, &payload.execution_config)?;
         validate_idempotency_policy(&payload.target, &payload.execution_config)?;
+        validate_approval_policy(&payload.execution_config)?;
         payload.input_mapping.validate_paths()?;
         payload.output_mapping.validate_paths()?;
         Ok(())
@@ -307,6 +310,7 @@ impl AdminService {
         validate_protocol_target(operation.protocol, &operation.target)?;
         validate_response_cache_policy(&operation.target, &operation.execution_config)?;
         validate_idempotency_policy(&operation.target, &operation.execution_config)?;
+        validate_approval_policy(&operation.execution_config)?;
         operation.input_mapping.validate_paths()?;
         operation.output_mapping.validate_paths()?;
         Ok(())

apps/admin-api/src/service/api_keys.rs

@@ -1,7 +1,10 @@
-use crank_core::{AgentId, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyStatus, WorkspaceId};
+use crank_core::{
+    AgentId, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyKind, PlatformApiKeyScope,
+    PlatformApiKeyStatus, WorkspaceId,
+};
 use crank_registry::{CreatePlatformApiKeyRequest, PlatformApiKeyRecord};
 use serde_json::json;
-use time::OffsetDateTime;
+use time::{OffsetDateTime, format_description::well_known::Rfc3339};
 use tracing::instrument;
 
 use crate::{
@@ -53,7 +56,19 @@ impl AdminService {
                 )
             })?;
 
-        let secret = generate_access_secret("crk");
+        validate_platform_api_key_payload(&payload)?;
+
+        let expires_at = match payload.expires_at.as_deref() {
+            Some(value) => Some(
+                OffsetDateTime::parse(value, &Rfc3339)
+                    .map_err(|_| ApiError::validation("expires_at must be RFC3339 timestamp"))?,
+            ),
+            None => None,
+        };
+        let secret = generate_access_secret(match payload.key_kind {
+            PlatformApiKeyKind::McpClient => "crk",
+            PlatformApiKeyKind::Approval => "crk_appr",
+        });
         let api_key = PlatformApiKeyRecord {
             api_key: PlatformApiKey {
                 id: PlatformApiKeyId::new(new_prefixed_id("pk")),
@@ -61,10 +76,13 @@ impl AdminService {
                 agent_id: Some(agent_id.clone()),
                 name: payload.name,
                 prefix: secret.chars().take(16).collect(),
+                key_kind: payload.key_kind,
                 scopes: payload.scopes,
                 status: PlatformApiKeyStatus::Active,
                 created_at: OffsetDateTime::now_utc(),
                 last_used_at: None,
+                expires_at,
+                allowed_origins: payload.allowed_origins,
             },
         };
 
@@ -109,3 +127,38 @@ impl AdminService {
         Ok(())
     }
 }
+
+fn validate_platform_api_key_payload(payload: &PlatformApiKeyPayload) -> Result<(), ApiError> {
+    if payload.name.trim().is_empty() {
+        return Err(ApiError::validation("key name is required"));
+    }
+    if payload.scopes.is_empty() {
+        return Err(ApiError::validation("at least one key scope is required"));
+    }
+
+    let valid = payload.scopes.iter().all(|scope| match payload.key_kind {
+        PlatformApiKeyKind::McpClient => matches!(
+            scope,
+            PlatformApiKeyScope::Read | PlatformApiKeyScope::Write | PlatformApiKeyScope::Deploy
+        ),
+        PlatformApiKeyKind::Approval => matches!(
+            scope,
+            PlatformApiKeyScope::Approve
+                | PlatformApiKeyScope::Deny
+                | PlatformApiKeyScope::ReadPending
+        ),
+    });
+    if !valid {
+        return Err(ApiError::validation(
+            "key scopes do not match selected key kind",
+        ));
+    }
+
+    if payload.key_kind == PlatformApiKeyKind::Approval && payload.allowed_origins.len() > 20 {
+        return Err(ApiError::validation(
+            "approval key can contain at most 20 allowed origins",
+        ));
+    }
+
+    Ok(())
+}

apps/admin-api/src/service/demo.rs

@@ -2,12 +2,12 @@ use std::collections::BTreeMap;
 
 use crank_core::{
     AgentId, InvocationLevel, InvocationSource, InvocationStatus, MembershipRole, OperationId,
-    OperationSecurityLevel, PlatformApiKeyScope, PlatformApiKeyStatus, Protocol, Target,
-    WizardState, WorkspaceId,
+    OperationSecurityLevel, PlatformApiKeyKind, PlatformApiKeyScope, PlatformApiKeyStatus,
+    Protocol, Target, WizardState, WorkspaceId,
 };
 use crank_mapping::{JsonPathRoot, infer_mapping_from_samples};
 use crank_mapping::{MappingRule, MappingSet};
-use crank_registry::{ListInvocationLogsQuery, OperationSummary, SampleKind};
+use crank_registry::{ListInvocationLogsQuery, OperationSummary, RegistryError, SampleKind};
 use crank_schema::Schema;
 use serde_json::{Value, json};
 
@@ -99,11 +99,8 @@ impl AdminService {
                     .name
                     .starts_with("weather_current_open_meteo_smoke_")
             {
-                self.delete_operation(
-                    workspace_id,
-                    &OperationId::new(operation.id.as_str().to_owned()),
-                )
-                .await?;
+                self.delete_legacy_demo_operation_if_safe(workspace_id, &operation.id)
+                    .await?;
             }
         }
 
@@ -113,17 +110,36 @@ impl AdminService {
             "weather_current_open_meteo",
         ] {
             if let Some(operation) = self.find_operation_by_name(workspace_id, name).await? {
-                self.delete_operation(
-                    workspace_id,
-                    &OperationId::new(operation.id.as_str().to_owned()),
-                )
-                .await?;
+                self.delete_legacy_demo_operation_if_safe(workspace_id, &operation.id)
+                    .await?;
             }
         }
 
         Ok(())
     }
 
+    async fn delete_legacy_demo_operation_if_safe(
+        &self,
+        workspace_id: &WorkspaceId,
+        operation_id: &OperationId,
+    ) -> Result<(), ApiError> {
+        match self
+            .registry
+            .delete_operation(workspace_id, operation_id)
+            .await
+        {
+            Ok(()) => Ok(()),
+            Err(RegistryError::OperationHasPublishedAgentBindings { .. }) => {
+                tracing::warn!(
+                    operation_id = %operation_id.as_str(),
+                    "legacy demo operation is still bound to a published agent; leaving it in place"
+                );
+                Ok(())
+            }
+            Err(error) => Err(ApiError::from(error)),
+        }
+    }
+
     async fn ensure_demo_platform_api_key(
         &self,
         workspace_id: &WorkspaceId,
@@ -146,7 +162,10 @@ impl AdminService {
                     agent_id,
                     PlatformApiKeyPayload {
                         name: name.to_owned(),
+                        key_kind: PlatformApiKeyKind::McpClient,
                         scopes,
+                        expires_at: None,
+                        allowed_origins: Vec::new(),
                     },
                 )
                 .await?
@@ -368,6 +387,7 @@ fn demo_rest_operation_payload() -> OperationPayload {
             response_cache: None,
             idempotency: None,
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },
@@ -392,6 +412,7 @@ fn demo_rest_operation_payload() -> OperationPayload {
             input_sample: Some(input),
             output_sample: Some(output),
             test_input: Some(demo_rest_input_sample()),
+            import_findings: Vec::new(),
         }),
     }
 }

apps/admin-api/src/service/imports.rs

@@ -0,0 +1,286 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use crank_core::{
+    ExecutionConfig, OperationSecurityLevel, Protocol, ToolQualityFinding, ToolQualitySeverity,
+    WorkspaceId,
+};
+use crank_import::rest::{
+    ImportFinding, ImportFindingSeverity, ImportOperationCandidate, operation_draft_from_candidate,
+};
+use crank_registry::{
+    CreateImportJobRequest, FinishImportJobRequest, ImportJobId, ImportJobKind, ImportJobStatus,
+};
+use serde_json::json;
+use time::{Duration, OffsetDateTime, format_description::well_known::Rfc3339};
+use tracing::{info, instrument};
+
+use crate::{
+    error::ApiError,
+    service::{
+        AdminService, OpenApiImportCreatePayload, OpenApiImportCreateResponse,
+        OpenApiImportCreatedOperation, OpenApiImportPreviewPayload, OpenApiImportPreviewResponse,
+        OpenApiImportSkippedOperation, OperationPayload, new_prefixed_id,
+    },
+};
+
+const IMPORT_JOB_TTL_HOURS: i64 = 24;
+
+impl AdminService {
+    #[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str()))]
+    pub async fn preview_openapi_import(
+        &self,
+        workspace_id: &WorkspaceId,
+        payload: OpenApiImportPreviewPayload,
+    ) -> Result<OpenApiImportPreviewResponse, ApiError> {
+        self.ensure_workspace_exists(workspace_id).await?;
+        let _ = self.registry.delete_expired_import_jobs().await;
+
+        let preview = crank_import::rest::preview_document(&payload.document)
+            .map_err(|error| ApiError::validation(error.to_string()))?;
+        let now = OffsetDateTime::now_utc();
+        let expires_at = now + Duration::hours(IMPORT_JOB_TTL_HOURS);
+        let job_id = ImportJobId::new(new_prefixed_id("imp"));
+        let preview_payload = serde_json::to_value(&preview)
+            .map_err(|error| ApiError::internal(error.to_string()))?;
+
+        self.registry
+            .create_import_job(CreateImportJobRequest {
+                id: &job_id,
+                workspace_id,
+                kind: ImportJobKind::OpenApi,
+                source_format: &preview.source.format,
+                source_version: preview.source.version.as_deref(),
+                status: ImportJobStatus::Completed,
+                preview_payload: &preview_payload,
+                created_at: &now,
+                expires_at: &expires_at,
+            })
+            .await?;
+
+        Ok(OpenApiImportPreviewResponse {
+            job_id: job_id.as_str().to_owned(),
+            expires_at: expires_at
+                .format(&Rfc3339)
+                .map_err(|error| ApiError::internal(error.to_string()))?,
+            preview,
+        })
+    }
+
+    #[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str(), job_id = %job_id.as_str()))]
+    pub async fn create_openapi_import(
+        &self,
+        workspace_id: &WorkspaceId,
+        job_id: &ImportJobId,
+        payload: OpenApiImportCreatePayload,
+    ) -> Result<OpenApiImportCreateResponse, ApiError> {
+        self.ensure_workspace_exists(workspace_id).await?;
+        let _ = self.registry.delete_expired_import_jobs().await;
+
+        if !matches!(payload.conflict_mode.as_str(), "skip" | "rename") {
+            return Err(ApiError::validation(
+                "unsupported conflict_mode; supported values are skip and rename",
+            ));
+        }
+
+        let job = self
+            .registry
+            .get_import_job(workspace_id, job_id)
+            .await?
+            .ok_or_else(|| {
+                ApiError::not_found_with_context(
+                    "import job was not found",
+                    json!({ "job_id": job_id.as_str() }),
+                )
+            })?;
+        if job.expires_at <= OffsetDateTime::now_utc() {
+            return Err(ApiError::validation("import preview has expired"));
+        }
+        if job.kind != ImportJobKind::OpenApi {
+            return Err(ApiError::validation("import job kind is not openapi"));
+        }
+
+        let preview: crank_import::rest::ImportPreview =
+            serde_json::from_value(job.preview_payload.clone())
+                .map_err(|error| ApiError::internal(error.to_string()))?;
+        let selected = payload
+            .selected_operation_keys
+            .iter()
+            .cloned()
+            .collect::<BTreeSet<_>>();
+        if selected.is_empty() {
+            return Err(ApiError::validation(
+                "selected_operation_keys must contain at least one operation",
+            ));
+        }
+
+        let mut candidates = BTreeMap::new();
+        for group in &preview.groups {
+            for operation in &group.operations {
+                candidates.insert(operation.key.clone(), operation);
+            }
+        }
+
+        let mut created = Vec::new();
+        let mut skipped = Vec::new();
+        let mut findings = Vec::new();
+        let mut created_ids = Vec::new();
+
+        for operation_key in selected {
+            let Some(candidate) = candidates.get(&operation_key) else {
+                skipped.push(OpenApiImportSkippedOperation {
+                    operation_key,
+                    name: String::new(),
+                    reason: "operation was not found in import preview".to_owned(),
+                });
+                continue;
+            };
+            let mut draft =
+                operation_draft_from_candidate(candidate, payload.server_url.as_deref());
+            attach_import_findings(&mut draft, candidate);
+            if let Some(existing_name) = self
+                .find_operation_by_name(workspace_id, &draft.name)
+                .await?
+                .map(|operation| operation.name)
+            {
+                if payload.conflict_mode == "skip" {
+                    skipped.push(OpenApiImportSkippedOperation {
+                        operation_key: candidate.key.clone(),
+                        name: draft.name.clone(),
+                        reason: "operation with this name already exists".to_owned(),
+                    });
+                    findings.push(ImportFinding {
+                        code: "operation_name_conflict".to_owned(),
+                        severity: ImportFindingSeverity::Warning,
+                        message: format!(
+                            "Операция {} уже существует и была пропущена.",
+                            draft.name
+                        ),
+                        operation_key: Some(candidate.key.clone()),
+                    });
+                    continue;
+                }
+
+                let renamed = self
+                    .next_available_operation_name(workspace_id, &draft.name)
+                    .await?;
+                findings.push(ImportFinding {
+                    code: "operation_name_renamed".to_owned(),
+                    severity: ImportFindingSeverity::Info,
+                    message: format!(
+                        "Операция {existing_name} уже существует, новый черновик создан как {renamed}."
+                    ),
+                    operation_key: Some(candidate.key.clone()),
+                });
+                draft.name = renamed;
+            }
+
+            let payload = OperationPayload {
+                name: draft.name.clone(),
+                display_name: draft.display_name.clone(),
+                category: draft.category,
+                protocol: Protocol::Rest,
+                security_level: OperationSecurityLevel::Standard,
+                target: crank_core::Target::Rest(draft.target),
+                input_schema: draft.input_schema,
+                output_schema: draft.output_schema,
+                input_mapping: draft.input_mapping,
+                output_mapping: draft.output_mapping,
+                execution_config: ExecutionConfig {
+                    timeout_ms: 10_000,
+                    retry_policy: None,
+                    response_cache: None,
+                    idempotency: None,
+                    safety: None,
+                    approval_policy: None,
+                    auth_profile_ref: None,
+                    headers: BTreeMap::new(),
+                },
+                tool_description: draft.tool_description,
+                wizard_state: draft.wizard_state,
+            };
+            let result = self.create_operation(workspace_id, payload).await?;
+            created_ids.push(result.operation_id.clone());
+            created.push(OpenApiImportCreatedOperation {
+                operation_id: result.operation_id,
+                name: draft.name,
+                version: result.version,
+            });
+        }
+
+        let finished_at = OffsetDateTime::now_utc();
+        self.registry
+            .finish_import_job(FinishImportJobRequest {
+                id: job_id,
+                status: ImportJobStatus::Completed,
+                created_operation_ids: &json!(created_ids),
+                error_text: None,
+                finished_at: &finished_at,
+            })
+            .await?;
+        info!(
+            created = created.len(),
+            skipped = skipped.len(),
+            "openapi import created drafts"
+        );
+
+        Ok(OpenApiImportCreateResponse {
+            created,
+            skipped,
+            findings,
+        })
+    }
+
+    async fn next_available_operation_name(
+        &self,
+        workspace_id: &WorkspaceId,
+        base_name: &str,
+    ) -> Result<String, ApiError> {
+        for index in 2.. {
+            let candidate = format!("{base_name}_{index}");
+            if self
+                .find_operation_by_name(workspace_id, &candidate)
+                .await?
+                .is_none()
+            {
+                return Ok(candidate);
+            }
+        }
+
+        unreachable!()
+    }
+}
+
+fn attach_import_findings(
+    draft: &mut crank_import::rest::RestImportCandidate,
+    candidate: &ImportOperationCandidate,
+) {
+    let findings = candidate
+        .findings
+        .iter()
+        .map(tool_quality_finding_from_import)
+        .collect::<Vec<_>>();
+    if findings.is_empty() {
+        return;
+    }
+
+    let mut wizard_state = draft.wizard_state.take().unwrap_or_default();
+    wizard_state.import_findings = findings;
+    draft.wizard_state = Some(wizard_state);
+}
+
+fn tool_quality_finding_from_import(finding: &ImportFinding) -> ToolQualityFinding {
+    ToolQualityFinding {
+        severity: match finding.severity {
+            ImportFindingSeverity::Info => ToolQualitySeverity::Info,
+            ImportFindingSeverity::Warning => ToolQualitySeverity::Warning,
+            ImportFindingSeverity::Error => ToolQualitySeverity::Error,
+        },
+        code: format!("openapi_import.{}", finding.code),
+        message: finding.message.clone(),
+        suggested_action: Some(
+            "Откройте черновик в мастере и уточните описание, схемы или маппинг перед публикацией."
+                .to_owned(),
+        ),
+        field_path: finding.operation_key.clone(),
+    }
+}

apps/admin-api/src/service/observability.rs

@@ -1,11 +1,21 @@
-use crank_core::{AgentId, InvocationLogId, OperationId, UsagePeriod, WorkspaceId};
-use crank_registry::{InvocationLogRecord, ListInvocationLogsQuery, UsageQuery, UsageRollupRecord};
+use crank_core::{
+    AgentId, ApprovalRequestId, ApprovalRequestStatus, InvocationLogId, OperationId, UsagePeriod,
+    WorkspaceId,
+};
+use crank_registry::{
+    ApprovalRequestRecord, ExpireApprovalRequest, InvocationLogRecord, ListApprovalRequestsQuery,
+    ListInvocationLogsQuery, UsageQuery, UsageRollupRecord,
+};
 use serde_json::json;
+use time::OffsetDateTime;
 use tracing::instrument;
 
 use crate::{
     error::ApiError,
-    service::{AdminService, LogsQuery, UsageOverviewResponse, UsageRequestQuery, usage_window},
+    service::{
+        AdminService, ApprovalsQuery, LogsQuery, UsageOverviewResponse, UsageRequestQuery,
+        usage_window,
+    },
 };
 
 impl AdminService {
@@ -52,6 +62,76 @@ impl AdminService {
             })
     }
 
+    #[instrument(skip(self))]
+    pub async fn list_approvals(
+        &self,
+        workspace_id: &WorkspaceId,
+        query: ApprovalsQuery,
+    ) -> Result<Vec<ApprovalRequestRecord>, ApiError> {
+        self.ensure_workspace_exists(workspace_id).await?;
+        let records = self
+            .registry
+            .list_approval_requests(ListApprovalRequestsQuery {
+                workspace_id,
+                status: query.status,
+                limit: query.limit.unwrap_or(50).clamp(1, 200),
+            })
+            .await?;
+
+        let mut normalized = Vec::with_capacity(records.len());
+        for record in records {
+            let record = self.normalize_approval_record(record).await?;
+            if query.status.is_none() || record.approval.status == query.status.unwrap() {
+                normalized.push(record);
+            }
+        }
+
+        Ok(normalized)
+    }
+
+    #[instrument(skip(self))]
+    pub async fn get_approval(
+        &self,
+        workspace_id: &WorkspaceId,
+        approval_id: &ApprovalRequestId,
+    ) -> Result<ApprovalRequestRecord, ApiError> {
+        self.ensure_workspace_exists(workspace_id).await?;
+        let record = self
+            .registry
+            .get_approval_request(workspace_id, approval_id)
+            .await?
+            .ok_or_else(|| {
+                ApiError::not_found_with_context(
+                    format!("approval request {} was not found", approval_id.as_str()),
+                    json!({ "approval_id": approval_id.as_str() }),
+                )
+            })?;
+
+        self.normalize_approval_record(record).await
+    }
+
+    async fn normalize_approval_record(
+        &self,
+        record: ApprovalRequestRecord,
+    ) -> Result<ApprovalRequestRecord, ApiError> {
+        if record.approval.status != ApprovalRequestStatus::Pending
+            || record.approval.expires_at > OffsetDateTime::now_utc()
+        {
+            return Ok(record);
+        }
+
+        Ok(self
+            .registry
+            .expire_approval_request(ExpireApprovalRequest {
+                workspace_id: &record.approval.workspace_id,
+                agent_id: &record.approval.agent_id,
+                approval_id: &record.approval.id,
+                expired_at: OffsetDateTime::now_utc(),
+            })
+            .await?
+            .unwrap_or(record))
+    }
+
     #[instrument(skip(self))]
     pub async fn get_usage_overview(
         &self,

apps/admin-api/src/service/operation_validation.rs

@@ -105,16 +105,53 @@ pub(super) fn validate_idempotency_policy(
     Ok(())
 }
 
+pub(super) fn validate_approval_policy(
+    execution_config: &crank_core::ExecutionConfig,
+) -> Result<(), ApiError> {
+    let Some(policy) = execution_config.approval_policy.as_ref() else {
+        return Ok(());
+    };
+
+    if !policy.required {
+        return Ok(());
+    }
+
+    if policy.ttl_seconds == 0 || policy.ttl_seconds > 300 {
+        return Err(ApiError::validation_with_context(
+            "approval ttl must be between 1 and 300 seconds".to_owned(),
+            json!({
+                "field": "execution_config.approval_policy.ttl_seconds",
+            }),
+        ));
+    }
+
+    if let Some(message) = policy.elicitation_message.as_ref()
+        && message.chars().count() > 240
+    {
+        return Err(ApiError::validation_with_context(
+            "approval elicitation message must be at most 240 characters".to_owned(),
+            json!({
+                "field": "execution_config.approval_policy.elicitation_message",
+            }),
+        ));
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeMap;
 
     use crank_core::{
-        ExecutionConfig, HttpMethod, IdempotencyMode, IdempotencyPolicy, ResponseCachePolicy,
-        RestTarget, Target,
+        ExecutionConfig, HttpMethod, IdempotencyMode, IdempotencyPolicy, OperationApprovalMode,
+        OperationApprovalPayloadPreviewMode, OperationApprovalPolicy, OperationApprovalRiskLevel,
+        ResponseCachePolicy, RestTarget, Target,
     };
 
-    use super::{validate_idempotency_policy, validate_response_cache_policy};
+    use super::{
+        validate_approval_policy, validate_idempotency_policy, validate_response_cache_policy,
+    };
 
     fn cacheable_execution_config() -> ExecutionConfig {
         ExecutionConfig {
@@ -123,6 +160,7 @@ mod tests {
             response_cache: Some(ResponseCachePolicy { ttl_ms: 5_000 }),
             idempotency: None,
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         }
@@ -140,6 +178,7 @@ mod tests {
                 header_name: Some("Idempotency-Key".to_owned()),
             }),
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         }
@@ -238,4 +277,42 @@ mod tests {
             "required idempotency needs input_field or header_name"
         );
     }
+
+    #[test]
+    fn accepts_valid_approval_policy() {
+        let mut config = cacheable_execution_config();
+        config.approval_policy = Some(OperationApprovalPolicy {
+            required: true,
+            mode: OperationApprovalMode::Custom,
+            risk_level: OperationApprovalRiskLevel::Dangerous,
+            ttl_seconds: 300,
+            show_payload_preview: true,
+            payload_preview_mode: OperationApprovalPayloadPreviewMode::MaskedJson,
+            elicitation_message: None,
+        });
+
+        validate_approval_policy(&config).unwrap();
+    }
+
+    #[test]
+    fn rejects_invalid_approval_policy() {
+        let mut config = cacheable_execution_config();
+        config.approval_policy = Some(OperationApprovalPolicy {
+            required: true,
+            mode: OperationApprovalMode::Custom,
+            risk_level: OperationApprovalRiskLevel::Dangerous,
+            ttl_seconds: 0,
+            show_payload_preview: true,
+            payload_preview_mode: OperationApprovalPayloadPreviewMode::MaskedJson,
+            elicitation_message: None,
+        });
+
+        let error = validate_approval_policy(&config).unwrap_err();
+
+        assert!(matches!(error, crate::error::ApiError::Validation { .. }));
+        assert_eq!(
+            error.to_string(),
+            "approval ttl must be between 1 and 300 seconds"
+        );
+    }
 }

apps/admin-api/tests/integration.rs

@@ -2,6 +2,7 @@ mod integration {
     mod auth_rate_limit;
     mod common;
     mod community_access_usage;
+    mod openapi_import;
     mod operations_agents;
     mod secrets_import_auth;
 }

apps/admin-api/tests/integration/common.rs

@@ -297,6 +297,7 @@ pub(super) fn test_operation_payload(base_url: &str, name: &str) -> OperationPay
             response_cache: None,
             idempotency: None,
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },

apps/admin-api/tests/integration/community_access_usage.rs

@@ -12,8 +12,8 @@ use std::{
 use async_trait::async_trait;
 use axum::{Json, Router, routing::post};
 use crank_core::{
-    ExecutionConfig, HttpMethod, MembershipRole, OperationSecurityLevel, Protocol,
-    ResponseCachePolicy, RestTarget, SecretKind, Target, ToolDescription, WorkspaceId,
+    AgentId, ExecutionConfig, HttpMethod, MembershipRole, OperationId, OperationSecurityLevel,
+    Protocol, ResponseCachePolicy, RestTarget, SecretKind, Target, ToolDescription, WorkspaceId,
 };
 use crank_core::{IdentityError, IdentityProvider, IdentityProviderKind, LoginOutcome};
 use crank_mapping::{MappingRule, MappingSet};
@@ -27,7 +27,9 @@ use tokio::net::TcpListener;
 use admin_api::{
     app::build_app,
     auth::{AuthSettings, BootstrapAdminConfig, hash_password},
-    service::{AdminService, AdminServiceBuilder, OperationPayload},
+    service::{
+        AdminService, AdminServiceBuilder, AgentBindingPayload, AgentPayload, OperationPayload,
+    },
     state::AppState,
 };
 
@@ -151,6 +153,7 @@ async fn manages_agent_platform_api_keys() {
             .post(format!("{base_url}/agents/{agent_id}/platform-api-keys"))
             .json(&json!({
                 "name": "sales-routing-primary",
+                "key_kind": "mcp_client",
                 "scopes": ["read", "write"]
             }))
             .send()
@@ -162,6 +165,31 @@ async fn manages_agent_platform_api_keys() {
         .as_str()
         .unwrap()
         .to_owned();
+    let created_approval_key = assert_success_json(
+        client
+            .post(format!("{base_url}/agents/{agent_id}/platform-api-keys"))
+            .json(&json!({
+                "name": "sales-routing-approver",
+                "key_kind": "approval",
+                "scopes": ["approve", "deny"],
+                "allowed_origins": ["https://client.example.test"]
+            }))
+            .send()
+            .await
+            .unwrap(),
+    )
+    .await;
+    let invalid_mixed_scope_status = client
+        .post(format!("{base_url}/agents/{agent_id}/platform-api-keys"))
+        .json(&json!({
+            "name": "invalid-mixed-scope",
+            "key_kind": "approval",
+            "scopes": ["read", "approve"]
+        }))
+        .send()
+        .await
+        .unwrap()
+        .status();
 
     let listed_keys = assert_success_json(
         client
@@ -190,14 +218,27 @@ async fn manages_agent_platform_api_keys() {
         .status();
 
     assert_eq!(created_key["api_key"]["api_key"]["agent_id"], agent_id);
+    assert_eq!(created_key["api_key"]["api_key"]["key_kind"], "mcp_client");
+    assert_eq!(
+        created_approval_key["api_key"]["api_key"]["key_kind"],
+        "approval"
+    );
+    assert!(
+        created_approval_key["secret"]
+            .as_str()
+            .unwrap()
+            .starts_with("crk_appr_")
+    );
+    assert_eq!(
+        created_approval_key["api_key"]["api_key"]["allowed_origins"],
+        json!(["https://client.example.test"])
+    );
+    assert_eq!(invalid_mixed_scope_status, reqwest::StatusCode::BAD_REQUEST);
     assert_eq!(
         listed_keys["items"][0]["api_key"]["agent_id"],
         json!(agent_id)
     );
-    assert_eq!(
-        listed_keys["items"][0]["api_key"]["name"],
-        "sales-routing-primary"
-    );
+    assert_eq!(listed_keys["items"].as_array().unwrap().len(), 2);
     assert!(created_key["secret"].as_str().unwrap().starts_with("crk_"));
     assert_eq!(revoke_status, reqwest::StatusCode::NO_CONTENT);
     assert_eq!(delete_status, reqwest::StatusCode::NO_CONTENT);
@@ -398,6 +439,61 @@ async fn seeds_demo_assets_for_live_ui() {
 
     service.bootstrap_admin_user().await.unwrap();
     service.seed_demo_assets().await.unwrap();
+
+    let smoke_operation = service
+        .create_operation(
+            &WorkspaceId::new(DEFAULT_WORKSPACE_ID),
+            test_operation_payload("https://example.test", "internal_health_smoke_bound"),
+        )
+        .await
+        .unwrap();
+    let smoke_operation_id = OperationId::new(smoke_operation.operation_id);
+    service
+        .publish_operation(
+            &WorkspaceId::new(DEFAULT_WORKSPACE_ID),
+            &smoke_operation_id,
+            smoke_operation.version,
+        )
+        .await
+        .unwrap();
+    let smoke_agent = service
+        .create_agent(
+            &WorkspaceId::new(DEFAULT_WORKSPACE_ID),
+            AgentPayload {
+                slug: "legacy-smoke-agent".to_owned(),
+                display_name: "Legacy Smoke Agent".to_owned(),
+                description: "Keeps a legacy smoke operation published".to_owned(),
+                instructions: json!({}),
+                tool_selection_policy: json!({}),
+            },
+        )
+        .await
+        .unwrap();
+    let smoke_agent_id = AgentId::new(smoke_agent.agent_id);
+    service
+        .save_agent_bindings(
+            &WorkspaceId::new(DEFAULT_WORKSPACE_ID),
+            &smoke_agent_id,
+            vec![AgentBindingPayload {
+                operation_id: smoke_operation_id.as_str().to_owned(),
+                operation_version: smoke_operation.version,
+                tool_name: "legacy_health_smoke".to_owned(),
+                tool_title: "Legacy health smoke".to_owned(),
+                tool_description_override: None,
+                enabled: true,
+            }],
+        )
+        .await
+        .unwrap();
+    service
+        .publish_agent(
+            &WorkspaceId::new(DEFAULT_WORKSPACE_ID),
+            &smoke_agent_id,
+            smoke_agent.version,
+        )
+        .await
+        .unwrap();
+
     service.seed_demo_assets().await.unwrap();
 
     let owner = registry
@@ -431,15 +527,18 @@ async fn seeds_demo_assets_for_live_ui() {
             .iter()
             .any(|operation| operation.name == "crm_create_lead")
     );
+    assert!(!operations.iter().any(
+        |operation| operation.name.starts_with("internal_health_smoke_")
+            && operation.name != "internal_health_smoke_bound"
+    ));
     assert!(
-        !operations
+        operations
             .iter()
-            .any(|operation| operation.name.starts_with("internal_health_smoke_"))
+            .any(|operation| operation.name == "internal_health_smoke_bound")
     );
 
     let agents = service.list_agents(&default_workspace_id).await.unwrap();
-    assert_eq!(agents.len(), 1);
-    assert_eq!(agents[0].slug, "currency-rates");
+    assert!(agents.iter().any(|agent| agent.slug == "currency-rates"));
 
     assert!(agents.iter().any(|agent| agent.key_count > 0));
 

apps/admin-api/tests/integration/openapi_import.rs

@@ -0,0 +1,149 @@
+use admin_api::service::{OpenApiImportCreatePayload, OpenApiImportPreviewPayload};
+use crank_core::WorkspaceId;
+use serial_test::serial;
+
+use super::common::{
+    test_auth_settings, test_registry, test_secret_crypto, test_service, test_storage_root,
+};
+
+const OPENAPI3: &str = r#"
+openapi: 3.0.3
+info:
+  title: Frankfurter API
+servers:
+  - url: https://api.frankfurter.dev
+paths:
+  /v2/latest:
+    get:
+      operationId: latestRates
+      summary: Получить последние курсы валют
+      description: Курсы.
+      tags: [currency]
+      parameters:
+        - name: base
+          in: query
+          required: true
+          schema: { type: string }
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  base: { type: string }
+                  rates:
+                    type: object
+"#;
+
+#[tokio::test]
+#[serial]
+async fn previews_openapi_and_creates_draft_operations() {
+    let registry = test_registry().await;
+    let service = test_service(
+        registry,
+        test_storage_root("openapi_import"),
+        test_auth_settings(),
+        test_secret_crypto(),
+    );
+    let workspace_id = WorkspaceId::new("ws_default");
+
+    let preview = service
+        .preview_openapi_import(
+            &workspace_id,
+            OpenApiImportPreviewPayload {
+                document: OPENAPI3.to_owned(),
+            },
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(preview.preview.groups.len(), 1);
+    assert_eq!(
+        preview.preview.groups[0].operations[0].suggested_name,
+        "latest_rates"
+    );
+
+    let created = service
+        .create_openapi_import(
+            &workspace_id,
+            &preview.job_id.as_str().into(),
+            OpenApiImportCreatePayload {
+                selected_operation_keys: vec!["GET /v2/latest".to_owned()],
+                server_url: Some("https://api.frankfurter.dev".to_owned()),
+                conflict_mode: "skip".to_owned(),
+            },
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(created.created.len(), 1);
+    assert_eq!(created.created[0].name, "latest_rates");
+    assert!(created.skipped.is_empty());
+
+    let operations = service.list_operations(&workspace_id).await.unwrap();
+    assert!(
+        operations
+            .iter()
+            .any(|operation| operation.name == "latest_rates")
+    );
+    let imported = operations
+        .iter()
+        .find(|operation| operation.name == "latest_rates")
+        .unwrap();
+    let version = service
+        .get_operation_version(
+            &workspace_id,
+            &imported.id.as_str().into(),
+            imported.current_draft_version,
+        )
+        .await
+        .unwrap();
+    let import_findings = &version
+        .snapshot
+        .wizard_state
+        .as_ref()
+        .unwrap()
+        .import_findings;
+    assert!(
+        import_findings
+            .iter()
+            .any(|finding| finding.code == "openapi_import.weak_tool_description")
+    );
+
+    let skipped = service
+        .create_openapi_import(
+            &workspace_id,
+            &preview.job_id.as_str().into(),
+            OpenApiImportCreatePayload {
+                selected_operation_keys: vec!["GET /v2/latest".to_owned()],
+                server_url: Some("https://api.frankfurter.dev".to_owned()),
+                conflict_mode: "skip".to_owned(),
+            },
+        )
+        .await
+        .unwrap();
+
+    assert!(skipped.created.is_empty());
+    assert_eq!(skipped.skipped.len(), 1);
+    assert_eq!(skipped.skipped[0].name, "latest_rates");
+    assert_eq!(skipped.findings[0].code, "operation_name_conflict");
+
+    let renamed = service
+        .create_openapi_import(
+            &workspace_id,
+            &preview.job_id.as_str().into(),
+            OpenApiImportCreatePayload {
+                selected_operation_keys: vec!["GET /v2/latest".to_owned()],
+                server_url: Some("https://api.frankfurter.dev".to_owned()),
+                conflict_mode: "rename".to_owned(),
+            },
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(renamed.created.len(), 1);
+    assert_eq!(renamed.created[0].name, "latest_rates_2");
+    assert_eq!(renamed.findings[0].code, "operation_name_renamed");
+}

apps/mcp-server/Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.85-bookworm AS deps
+FROM rust:1.96.1-bookworm AS deps
 
 WORKDIR /app
 
@@ -36,7 +36,7 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/app/target \
     SQLX_OFFLINE=true cargo build --release -p mcp-server
 
-FROM rust:1.85-bookworm AS builder
+FROM rust:1.96.1-bookworm AS builder
 
 WORKDIR /app
 

apps/mcp-server/tests/integration/catalog_access.rs

@@ -1,5 +1,7 @@
 #![allow(dead_code, unused_imports)]
 
+mod approval_access;
+
 use super::common::*;
 
 use std::{
@@ -17,14 +19,18 @@ use axum::{
 };
 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 use crank_core::{
-    Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ExecutionConfig, HttpMethod,
-    Operation, OperationId, OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyScope,
-    PlatformApiKeyStatus, Protocol, RestTarget, Target, ToolDescription, WorkspaceId,
+    Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ApprovalRequest,
+    ApprovalRequestId, ApprovalRequestStatus, ExecutionConfig, HttpMethod, InvocationSource,
+    Operation, OperationApprovalMode, OperationApprovalPayloadPreviewMode, OperationApprovalPolicy,
+    OperationApprovalRiskLevel, OperationId, OperationStatus, PlatformApiKey, PlatformApiKeyId,
+    PlatformApiKeyScope, PlatformApiKeyStatus, Protocol, RestTarget, Target, ToolDescription,
+    WorkspaceId,
 };
 use crank_mapping::{MappingRule, MappingSet};
 use crank_registry::{
-    CreateAgentRequest, CreatePlatformApiKeyRequest, ListInvocationLogsQuery, PostgresRegistry,
-    PublishAgentRequest, PublishRequest, SaveAgentBindingsRequest,
+    CreateAgentRequest, CreateApprovalRequest, CreatePlatformApiKeyRequest,
+    ListInvocationLogsQuery, PostgresRegistry, PublishAgentRequest, PublishRequest,
+    SaveAgentBindingsRequest,
 };
 use crank_runtime::{
     InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, RuntimeExecutor,
@@ -476,6 +482,38 @@ async fn rejects_initialize_without_platform_api_key() {
     assert_eq!(response.status(), reqwest::StatusCode::UNAUTHORIZED);
 }
 
+#[tokio::test]
+async fn rejects_initialize_with_approval_platform_api_key() {
+    let registry = test_registry().await;
+    publish_agent_with_bindings(&registry, "sales-approval-key", vec![]).await;
+    let api_key =
+        create_approval_platform_api_key(&registry, "sales-approval-key", "approval-only").await;
+    let base_url = spawn_mcp_server(build_test_app(
+        registry,
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let response = client
+        .post(agent_mcp_url(&base_url, "sales-approval-key"))
+        .header(header::ACCEPT, "application/json, text/event-stream")
+        .header(header::AUTHORIZATION, format!("Bearer {api_key}"))
+        .json(&json!({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2025-11-25"
+            }
+        }))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), reqwest::StatusCode::UNAUTHORIZED);
+}
+
 #[tokio::test]
 async fn rejects_tool_call_with_read_only_platform_api_key() {
     let registry = test_registry().await;

apps/mcp-server/tests/integration/catalog_access/approval_access.rs

@@ -0,0 +1,617 @@
+use super::*;
+
+#[tokio::test]
+async fn approval_key_lists_and_decides_pending_requests() {
+    let registry = test_registry().await;
+    let upstream_base_url = spawn_upstream_server().await;
+    let operation = test_operation(&upstream_base_url, "crm_human_approval");
+    registry
+        .create_operation(&test_workspace_id(), &operation, Some("alice"))
+        .await
+        .unwrap();
+    publish_agent_with_bindings(
+        &registry,
+        "sales-human-approval",
+        vec![binding_for_operation(&operation)],
+    )
+    .await;
+    let approval = ApprovalRequest {
+        id: ApprovalRequestId::new("approval_mcp_01"),
+        workspace_id: test_workspace_id(),
+        agent_id: test_agent_id("sales-human-approval"),
+        operation_id: operation.id.clone(),
+        operation_version: 1,
+        status: ApprovalRequestStatus::Pending,
+        risk_level: OperationApprovalRiskLevel::Dangerous,
+        request_payload: json!({"email": "ada@example.com"}),
+        response_payload: None,
+        created_at: OffsetDateTime::now_utc(),
+        expires_at: OffsetDateTime::now_utc() + time::Duration::minutes(5),
+        decided_at: None,
+        decided_by_key_id: None,
+        decision_note: None,
+    };
+    registry
+        .create_approval_request(CreateApprovalRequest {
+            approval: &approval,
+        })
+        .await
+        .unwrap();
+
+    let approval_key =
+        create_approval_platform_api_key(&registry, "sales-human-approval", "approval-http").await;
+    let mcp_key = create_platform_api_key(
+        &registry,
+        "sales-human-approval",
+        "mcp-human-approval",
+        &[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
+    )
+    .await;
+    let base_url = spawn_mcp_server(build_test_app(
+        registry.clone(),
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let approvals_url = format!(
+        "{}/approvals",
+        agent_mcp_url(&base_url, "sales-human-approval")
+    );
+
+    let rejected = client
+        .get(&approvals_url)
+        .header(header::AUTHORIZATION, format!("Bearer {mcp_key}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(rejected.status(), reqwest::StatusCode::UNAUTHORIZED);
+
+    let pending = client
+        .get(&approvals_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(pending.status(), reqwest::StatusCode::OK);
+    let pending_body = pending.json::<Value>().await.unwrap();
+    assert_eq!(pending_body["items"].as_array().unwrap().len(), 1);
+    assert_eq!(
+        pending_body["items"][0]["approval"]["request_payload"],
+        json!({"email": "ada@example.com"})
+    );
+
+    let approve_url = format!(
+        "{}/approvals/{}/approve",
+        agent_mcp_url(&base_url, "sales-human-approval"),
+        approval.id
+    );
+    let approved = client
+        .post(&approve_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .json(&json!({ "approve": "yes", "note": "confirmed by test" }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(approved.status(), reqwest::StatusCode::OK);
+    let approved_body = approved.json::<Value>().await.unwrap();
+    assert_eq!(
+        approved_body["approval"]["status"],
+        Value::String("completed".to_owned())
+    );
+    assert_eq!(
+        approved_body["approval"]["response_payload"],
+        json!({ "id": "lead_123" })
+    );
+
+    let status_url = format!(
+        "{}/approvals/{}",
+        agent_mcp_url(&base_url, "sales-human-approval"),
+        approval.id
+    );
+    let current = client
+        .get(&status_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(current.status(), reqwest::StatusCode::OK);
+    let current_body = current.json::<Value>().await.unwrap();
+    assert_eq!(
+        current_body["approval"]["status"],
+        Value::String("completed".to_owned())
+    );
+    assert_eq!(
+        current_body["approval"]["response_payload"],
+        json!({ "id": "lead_123" })
+    );
+
+    let repeated_approve = client
+        .post(&approve_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .json(&json!({ "approve": "yes", "note": "duplicate confirmation" }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(repeated_approve.status(), reqwest::StatusCode::OK);
+    let repeated_body = repeated_approve.json::<Value>().await.unwrap();
+    assert_eq!(
+        repeated_body["approval"]["status"],
+        Value::String("completed".to_owned())
+    );
+    assert_eq!(
+        repeated_body["approval"]["response_payload"],
+        json!({ "id": "lead_123" })
+    );
+
+    let pending_after = client
+        .get(&approvals_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .send()
+        .await
+        .unwrap()
+        .json::<Value>()
+        .await
+        .unwrap();
+    assert!(pending_after["items"].as_array().unwrap().is_empty());
+
+    let logs = registry
+        .list_invocation_logs(ListInvocationLogsQuery {
+            workspace_id: &test_workspace_id(),
+            level: None,
+            search_text: None,
+            source: Some(InvocationSource::AgentToolCall),
+            operation_id: Some(&operation.id),
+            agent_id: Some(&test_agent_id("sales-human-approval")),
+            created_after: None,
+            limit: 10,
+        })
+        .await
+        .unwrap();
+    assert_eq!(logs.len(), 1);
+}
+
+#[tokio::test]
+async fn approval_key_denies_without_executing_upstream() {
+    let registry = test_registry().await;
+    let upstream_base_url = spawn_upstream_server().await;
+    let operation = test_operation(&upstream_base_url, "crm_human_deny");
+    registry
+        .create_operation(&test_workspace_id(), &operation, Some("alice"))
+        .await
+        .unwrap();
+    publish_agent_with_bindings(
+        &registry,
+        "sales-human-deny",
+        vec![binding_for_operation(&operation)],
+    )
+    .await;
+    let approval = ApprovalRequest {
+        id: ApprovalRequestId::new("approval_mcp_deny_01"),
+        workspace_id: test_workspace_id(),
+        agent_id: test_agent_id("sales-human-deny"),
+        operation_id: operation.id.clone(),
+        operation_version: 1,
+        status: ApprovalRequestStatus::Pending,
+        risk_level: OperationApprovalRiskLevel::Dangerous,
+        request_payload: json!({"email": "deny@example.com"}),
+        response_payload: None,
+        created_at: OffsetDateTime::now_utc(),
+        expires_at: OffsetDateTime::now_utc() + time::Duration::minutes(5),
+        decided_at: None,
+        decided_by_key_id: None,
+        decision_note: None,
+    };
+    registry
+        .create_approval_request(CreateApprovalRequest {
+            approval: &approval,
+        })
+        .await
+        .unwrap();
+
+    let approval_key =
+        create_approval_platform_api_key(&registry, "sales-human-deny", "approval-deny-http").await;
+    let base_url = spawn_mcp_server(build_test_app(
+        registry.clone(),
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let deny_url = format!(
+        "{}/approvals/{}/deny",
+        agent_mcp_url(&base_url, "sales-human-deny"),
+        approval.id
+    );
+
+    let denied = client
+        .post(&deny_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .json(&json!({ "approve": "no", "note": "rejected by test" }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(denied.status(), reqwest::StatusCode::OK);
+    let denied_body = denied.json::<Value>().await.unwrap();
+    assert_eq!(
+        denied_body["approval"]["status"],
+        Value::String("denied".to_owned())
+    );
+
+    let repeated_deny = client
+        .post(&deny_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .json(&json!({ "approve": "no", "note": "duplicate rejection" }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(repeated_deny.status(), reqwest::StatusCode::OK);
+    let repeated_body = repeated_deny.json::<Value>().await.unwrap();
+    assert_eq!(
+        repeated_body["approval"]["status"],
+        Value::String("denied".to_owned())
+    );
+
+    let logs = registry
+        .list_invocation_logs(ListInvocationLogsQuery {
+            workspace_id: &test_workspace_id(),
+            level: None,
+            search_text: None,
+            source: Some(InvocationSource::AgentToolCall),
+            operation_id: Some(&operation.id),
+            agent_id: Some(&test_agent_id("sales-human-deny")),
+            created_after: None,
+            limit: 10,
+        })
+        .await
+        .unwrap();
+    assert!(logs.is_empty());
+}
+
+#[tokio::test]
+async fn approval_key_expires_without_executing_upstream() {
+    let registry = test_registry().await;
+    let upstream_base_url = spawn_upstream_server().await;
+    let operation = test_operation(&upstream_base_url, "crm_human_expired");
+    registry
+        .create_operation(&test_workspace_id(), &operation, Some("alice"))
+        .await
+        .unwrap();
+    publish_agent_with_bindings(
+        &registry,
+        "sales-human-expired",
+        vec![binding_for_operation(&operation)],
+    )
+    .await;
+    let approval = ApprovalRequest {
+        id: ApprovalRequestId::new("approval_mcp_expired_01"),
+        workspace_id: test_workspace_id(),
+        agent_id: test_agent_id("sales-human-expired"),
+        operation_id: operation.id.clone(),
+        operation_version: 1,
+        status: ApprovalRequestStatus::Pending,
+        risk_level: OperationApprovalRiskLevel::Dangerous,
+        request_payload: json!({"email": "expired@example.com"}),
+        response_payload: None,
+        created_at: OffsetDateTime::now_utc() - time::Duration::minutes(10),
+        expires_at: OffsetDateTime::now_utc() - time::Duration::minutes(5),
+        decided_at: None,
+        decided_by_key_id: None,
+        decision_note: None,
+    };
+    registry
+        .create_approval_request(CreateApprovalRequest {
+            approval: &approval,
+        })
+        .await
+        .unwrap();
+
+    let approval_key =
+        create_approval_platform_api_key(&registry, "sales-human-expired", "approval-expired-http")
+            .await;
+    let base_url = spawn_mcp_server(build_test_app(
+        registry.clone(),
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let approve_url = format!(
+        "{}/approvals/{}/approve",
+        agent_mcp_url(&base_url, "sales-human-expired"),
+        approval.id
+    );
+
+    let expired = client
+        .post(&approve_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .json(&json!({ "approve": "yes", "note": "too late" }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(expired.status(), reqwest::StatusCode::OK);
+    let expired_body = expired.json::<Value>().await.unwrap();
+    assert_eq!(
+        expired_body["approval"]["status"],
+        Value::String("expired".to_owned())
+    );
+
+    let logs = registry
+        .list_invocation_logs(ListInvocationLogsQuery {
+            workspace_id: &test_workspace_id(),
+            level: None,
+            search_text: None,
+            source: Some(InvocationSource::AgentToolCall),
+            operation_id: Some(&operation.id),
+            agent_id: Some(&test_agent_id("sales-human-expired")),
+            created_after: None,
+            limit: 10,
+        })
+        .await
+        .unwrap();
+    assert!(logs.is_empty());
+}
+
+#[tokio::test]
+async fn tool_call_with_approval_policy_creates_pending_request() {
+    let registry = test_registry().await;
+    let upstream_base_url = spawn_upstream_server().await;
+    let mut operation = test_operation(&upstream_base_url, "crm_requires_human_approval");
+    operation.execution_config.approval_policy = Some(OperationApprovalPolicy {
+        required: true,
+        mode: OperationApprovalMode::Custom,
+        risk_level: OperationApprovalRiskLevel::Dangerous,
+        ttl_seconds: 300,
+        show_payload_preview: true,
+        payload_preview_mode: OperationApprovalPayloadPreviewMode::MaskedJson,
+        elicitation_message: None,
+    });
+    registry
+        .create_operation(&test_workspace_id(), &operation, Some("alice"))
+        .await
+        .unwrap();
+    registry
+        .publish_operation(PublishRequest {
+            workspace_id: &test_workspace_id(),
+            operation_id: &operation.id,
+            version: 1,
+            published_at: &OffsetDateTime::parse("2026-03-26T10:00:00Z", &Rfc3339).unwrap(),
+            published_by: Some("alice"),
+        })
+        .await
+        .unwrap();
+    publish_agent_for_operation(&registry, &operation, "sales-gated").await;
+    let api_key = create_platform_api_key(
+        &registry,
+        "sales-gated",
+        "mcp-gated",
+        &[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
+    )
+    .await;
+    let approval_key =
+        create_approval_platform_api_key(&registry, "sales-gated", "approval-gated").await;
+
+    let base_url = spawn_mcp_server(build_test_app(
+        registry,
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let mcp_url = agent_mcp_url(&base_url, "sales-gated");
+    let initialized_session = initialize_session(&client, &mcp_url, &api_key).await;
+
+    let tool_result = post_jsonrpc(
+        &client,
+        &mcp_url,
+        &api_key,
+        Some(&initialized_session),
+        json!({
+            "jsonrpc": "2.0",
+            "id": 9,
+            "method": "tools/call",
+            "params": {
+                "name": "crm_requires_human_approval",
+                "arguments": {
+                    "email": "ada@example.com"
+                }
+            }
+        }),
+    )
+    .await;
+
+    assert_eq!(
+        tool_result["result"]["structuredContent"]["status"],
+        "approval_required"
+    );
+    assert_eq!(tool_result["result"]["isError"], false);
+    let approval_id = tool_result["result"]["structuredContent"]["approval_id"]
+        .as_str()
+        .unwrap();
+    assert!(approval_id.starts_with("approval_"));
+
+    let approvals_url = format!("{}/approvals", agent_mcp_url(&base_url, "sales-gated"));
+    let pending = client
+        .get(&approvals_url)
+        .header(header::AUTHORIZATION, format!("Bearer {approval_key}"))
+        .send()
+        .await
+        .unwrap()
+        .json::<Value>()
+        .await
+        .unwrap();
+    assert_eq!(pending["items"].as_array().unwrap().len(), 1);
+    assert_eq!(pending["items"][0]["approval"]["id"], approval_id);
+    assert_eq!(
+        pending["items"][0]["approval"]["request_payload"]["email"],
+        "ada@example.com"
+    );
+}
+
+#[tokio::test]
+async fn elicitation_approval_requires_client_capability() {
+    let registry = test_registry().await;
+    let upstream_base_url = spawn_upstream_server().await;
+    let mut operation = test_operation(&upstream_base_url, "crm_requires_elicitation");
+    operation.execution_config.approval_policy = Some(OperationApprovalPolicy {
+        required: true,
+        mode: OperationApprovalMode::Elicitation,
+        risk_level: OperationApprovalRiskLevel::Normal,
+        ttl_seconds: 300,
+        show_payload_preview: true,
+        payload_preview_mode: OperationApprovalPayloadPreviewMode::MaskedJson,
+        elicitation_message: Some("Подтвердите создание лида.".to_owned()),
+    });
+    registry
+        .create_operation(&test_workspace_id(), &operation, Some("alice"))
+        .await
+        .unwrap();
+    registry
+        .publish_operation(PublishRequest {
+            workspace_id: &test_workspace_id(),
+            operation_id: &operation.id,
+            version: 1,
+            published_at: &OffsetDateTime::now_utc(),
+            published_by: Some("alice"),
+        })
+        .await
+        .unwrap();
+    publish_agent_with_bindings(
+        &registry,
+        "sales-elicitation-no-capability",
+        vec![binding_for_operation(&operation)],
+    )
+    .await;
+    let api_key = create_platform_api_key(
+        &registry,
+        "sales-elicitation-no-capability",
+        "mcp-elicitation-no-capability",
+        &[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
+    )
+    .await;
+    let base_url = spawn_mcp_server(build_test_app(
+        registry.clone(),
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let mcp_url = agent_mcp_url(&base_url, "sales-elicitation-no-capability");
+    let initialized_session = initialize_session(&client, &mcp_url, &api_key).await;
+
+    let tool_result = post_jsonrpc(
+        &client,
+        &mcp_url,
+        &api_key,
+        Some(&initialized_session),
+        json!({
+            "jsonrpc": "2.0",
+            "id": 7,
+            "method": "tools/call",
+            "params": {
+                "name": "crm_requires_elicitation",
+                "arguments": {
+                    "email": "ada@example.com"
+                }
+            }
+        }),
+    )
+    .await;
+
+    assert_eq!(tool_result["result"]["isError"], true);
+    assert_eq!(
+        tool_result["result"]["structuredContent"]["error"]["code"],
+        "approval_elicitation_not_supported"
+    );
+}
+
+#[tokio::test]
+async fn elicitation_approval_uses_session_capability_without_approval_key() {
+    let registry = test_registry().await;
+    let upstream_base_url = spawn_upstream_server().await;
+    let mut operation = test_operation(&upstream_base_url, "crm_requires_elicitation_supported");
+    operation.execution_config.approval_policy = Some(OperationApprovalPolicy {
+        required: true,
+        mode: OperationApprovalMode::Elicitation,
+        risk_level: OperationApprovalRiskLevel::Normal,
+        ttl_seconds: 300,
+        show_payload_preview: true,
+        payload_preview_mode: OperationApprovalPayloadPreviewMode::MaskedJson,
+        elicitation_message: Some("Подтвердите создание лида.".to_owned()),
+    });
+    registry
+        .create_operation(&test_workspace_id(), &operation, Some("alice"))
+        .await
+        .unwrap();
+    registry
+        .publish_operation(PublishRequest {
+            workspace_id: &test_workspace_id(),
+            operation_id: &operation.id,
+            version: 1,
+            published_at: &OffsetDateTime::now_utc(),
+            published_by: Some("alice"),
+        })
+        .await
+        .unwrap();
+    publish_agent_with_bindings(
+        &registry,
+        "sales-elicitation-supported",
+        vec![binding_for_operation(&operation)],
+    )
+    .await;
+    let api_key = create_platform_api_key(
+        &registry,
+        "sales-elicitation-supported",
+        "mcp-elicitation-supported",
+        &[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
+    )
+    .await;
+    let base_url = spawn_mcp_server(build_test_app(
+        registry.clone(),
+        Duration::from_millis(0),
+        Some("https://crank.example.com".to_owned()),
+    ))
+    .await;
+    let client = reqwest::Client::new();
+    let mcp_url = agent_mcp_url(&base_url, "sales-elicitation-supported");
+    let initialized_session = initialize_session_with_capabilities(
+        &client,
+        &mcp_url,
+        &api_key,
+        json!({ "elicitation": {} }),
+    )
+    .await;
+
+    let tool_result = post_jsonrpc(
+        &client,
+        &mcp_url,
+        &api_key,
+        Some(&initialized_session),
+        json!({
+            "jsonrpc": "2.0",
+            "id": 8,
+            "method": "tools/call",
+            "params": {
+                "name": "crm_requires_elicitation_supported",
+                "arguments": {
+                    "email": "ada@example.com"
+                }
+            }
+        }),
+    )
+    .await;
+
+    assert_eq!(tool_result["result"]["isError"], false);
+    assert_eq!(
+        tool_result["result"]["structuredContent"]["status"],
+        "elicitation_required"
+    );
+    assert_eq!(
+        tool_result["result"]["structuredContent"]["message"],
+        "Подтвердите создание лида."
+    );
+    assert_eq!(
+        tool_result["result"]["structuredContent"]["payload_preview"]["email"],
+        "ada@example.com"
+    );
+}

apps/mcp-server/tests/integration/common.rs

@@ -16,8 +16,9 @@ use axum::{
 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 use crank_core::{
     Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ExecutionConfig, HttpMethod,
-    Operation, OperationId, OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyScope,
-    PlatformApiKeyStatus, Protocol, RestTarget, Target, ToolDescription, WorkspaceId,
+    Operation, OperationId, OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyKind,
+    PlatformApiKeyScope, PlatformApiKeyStatus, Protocol, RestTarget, Target, ToolDescription,
+    WorkspaceId,
 };
 use crank_mapping::{MappingRule, MappingSet};
 use crank_registry::{
@@ -146,6 +147,15 @@ pub(super) async fn initialize_session(
     client: &reqwest::Client,
     mcp_url: &str,
     api_key: &str,
+) -> String {
+    initialize_session_with_capabilities(client, mcp_url, api_key, json!({})).await
+}
+
+pub(super) async fn initialize_session_with_capabilities(
+    client: &reqwest::Client,
+    mcp_url: &str,
+    api_key: &str,
+    capabilities: Value,
 ) -> String {
     let initialize_response = client
         .post(mcp_url)
@@ -156,7 +166,8 @@ pub(super) async fn initialize_session(
             "id": 1,
             "method": "initialize",
             "params": {
-                "protocolVersion": "2025-11-25"
+                "protocolVersion": "2025-11-25",
+                "capabilities": capabilities
             }
         }))
         .send()
@@ -236,17 +247,59 @@ pub(super) async fn create_platform_api_key(
     name: &str,
     scopes: &[PlatformApiKeyScope],
 ) -> String {
-    let secret = format!("crk_{}_{}", name, uuid::Uuid::now_v7().simple());
+    create_platform_api_key_with_kind(
+        registry,
+        agent_slug,
+        name,
+        PlatformApiKeyKind::McpClient,
+        scopes,
+        "crk",
+    )
+    .await
+}
+
+pub(super) async fn create_approval_platform_api_key(
+    registry: &PostgresRegistry,
+    agent_slug: &str,
+    name: &str,
+) -> String {
+    create_platform_api_key_with_kind(
+        registry,
+        agent_slug,
+        name,
+        PlatformApiKeyKind::Approval,
+        &[
+            PlatformApiKeyScope::ReadPending,
+            PlatformApiKeyScope::Approve,
+            PlatformApiKeyScope::Deny,
+        ],
+        "crk_appr",
+    )
+    .await
+}
+
+async fn create_platform_api_key_with_kind(
+    registry: &PostgresRegistry,
+    agent_slug: &str,
+    name: &str,
+    key_kind: PlatformApiKeyKind,
+    scopes: &[PlatformApiKeyScope],
+    prefix: &str,
+) -> String {
+    let secret = format!("{prefix}_{}_{}", name, uuid::Uuid::now_v7().simple());
     let api_key = PlatformApiKey {
         id: PlatformApiKeyId::new(format!("pk_{name}")),
         workspace_id: test_workspace_id(),
         agent_id: Some(test_agent_id(agent_slug)),
+        key_kind,
         name: name.to_owned(),
         prefix: secret.chars().take(16).collect(),
         scopes: scopes.to_vec(),
         status: PlatformApiKeyStatus::Active,
         created_at: OffsetDateTime::parse("2026-03-26T10:00:00Z", &Rfc3339).unwrap(),
         last_used_at: None,
+        expires_at: None,
+        allowed_origins: Vec::new(),
     };
 
     registry
@@ -444,6 +497,7 @@ pub(super) fn test_operation(base_url: &str, name: &str) -> Operation<Schema, Ma
             response_cache: None,
             idempotency: None,
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },

apps/mcp-server/tests/integration/transport_protocol.rs

@@ -689,6 +689,7 @@ async fn get_returns_not_found_for_expired_transport_session() {
             "2025-11-25",
             test_workspace_slug(),
             "sales-expired-session",
+            false,
             OffsetDateTime::parse("2026-05-01T10:00:00Z", &Rfc3339).unwrap(),
             Some(OffsetDateTime::parse("2026-05-01T10:00:01Z", &Rfc3339).unwrap()),
         )

apps/ui/css/logs.css

@@ -134,3 +134,188 @@
 }
 
 .refresh-btn:hover { color: var(--text-secondary); background: var(--bg-muted); }
+
+.approval-panel {
+  margin-bottom: 18px;
+}
+
+.approval-panel-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.approval-panel-title {
+  font-size: 15px;
+  font-weight: 650;
+  color: var(--text-primary);
+}
+
+.approval-panel-subtitle {
+  margin-top: 4px;
+  font-size: 12.5px;
+  line-height: 1.45;
+  color: var(--text-muted);
+}
+
+.approval-refresh-btn {
+  margin-left: 0;
+}
+
+.approval-list {
+  display: grid;
+  gap: 12px;
+  padding: 16px 20px 20px;
+}
+
+.approval-empty {
+  padding: 20px;
+  border: 1px dashed var(--border);
+  border-radius: 10px;
+  background: var(--bg-canvas);
+  color: var(--text-muted);
+  font-size: 13px;
+}
+
+.approval-empty-error {
+  border-color: rgba(248, 81, 73, 0.35);
+  color: var(--red);
+}
+
+.approval-item {
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: var(--bg-canvas);
+  padding: 14px;
+}
+
+.approval-pending {
+  border-color: rgba(210, 153, 34, 0.45);
+  background: linear-gradient(180deg, rgba(210, 153, 34, 0.08), var(--bg-canvas) 46%);
+}
+
+.approval-completed {
+  border-color: rgba(63, 185, 80, 0.28);
+}
+
+.approval-failed,
+.approval-denied,
+.approval-expired {
+  border-color: rgba(248, 81, 73, 0.26);
+}
+
+.approval-item-header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.approval-item-title {
+  font-size: 14px;
+  font-weight: 650;
+  color: var(--text-primary);
+}
+
+.approval-item-meta,
+.approval-timing,
+.approval-note {
+  margin-top: 5px;
+  font-size: 11.5px;
+  color: var(--text-muted);
+}
+
+.approval-item-body {
+  margin: 10px 0 0;
+  font-size: 13px;
+  line-height: 1.55;
+  color: var(--text-secondary);
+}
+
+.approval-status {
+  flex-shrink: 0;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  padding: 3px 9px;
+  font-size: 11px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.35px;
+  color: var(--text-muted);
+  background: var(--bg-overlay);
+}
+
+.approval-status-pending {
+  color: var(--amber);
+  border-color: rgba(210, 153, 34, 0.45);
+  background: rgba(210, 153, 34, 0.1);
+}
+
+.approval-status-completed {
+  color: var(--green);
+  border-color: rgba(63, 185, 80, 0.35);
+  background: rgba(63, 185, 80, 0.1);
+}
+
+.approval-status-denied,
+.approval-status-expired,
+.approval-status-failed {
+  color: var(--red);
+  border-color: rgba(248, 81, 73, 0.35);
+  background: rgba(248, 81, 73, 0.09);
+}
+
+.approval-payload-grid {
+  display: grid;
+  gap: 10px;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  margin-top: 12px;
+}
+
+.approval-payload-label {
+  margin-bottom: 5px;
+  font-size: 10.5px;
+  font-weight: 700;
+  letter-spacing: 0.45px;
+  text-transform: uppercase;
+  color: var(--text-muted);
+}
+
+.approval-payload-code {
+  margin: 0;
+  max-height: 180px;
+  overflow: auto;
+  border: 1px solid var(--border-subtle);
+  border-radius: 8px;
+  background: #161b22;
+  padding: 10px;
+  color: #c9d1d9;
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 11.5px;
+  line-height: 1.55;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+@media (max-width: 720px) {
+  .approval-panel-header {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .approval-refresh-btn {
+    justify-content: center;
+  }
+
+  .approval-item-header {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .approval-status {
+    align-self: flex-start;
+  }
+}

apps/ui/css/openapi-import.css

@@ -0,0 +1,498 @@
+.page-header-actions {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.openapi-import-modal[hidden] {
+  display: none;
+}
+
+.openapi-import-modal {
+  position: fixed;
+  inset: 0;
+  z-index: 2400;
+  display: flex;
+  align-items: flex-start;
+  justify-content: center;
+  padding: 28px 16px;
+  overflow: auto;
+  isolation: isolate;
+}
+
+.openapi-import-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 0;
+  background: rgba(1, 4, 9, 0.82);
+  backdrop-filter: blur(8px);
+}
+
+.openapi-import-dialog {
+  position: relative;
+  z-index: 1;
+  width: min(1040px, calc(100vw - 32px));
+  max-height: calc(100vh - 56px);
+  margin: 0 auto;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  border: 1px solid var(--border);
+  border-radius: 22px;
+  background: var(--bg-canvas);
+  box-shadow: 0 24px 80px rgba(0, 0, 0, 0.6);
+}
+
+.openapi-import-header {
+  display: flex;
+  justify-content: space-between;
+  gap: 18px;
+  padding: 22px 24px;
+  border-bottom: 1px solid var(--border);
+  background: var(--bg-canvas);
+}
+
+.openapi-import-header h2 {
+  margin: 0 0 6px;
+  font-size: 22px;
+}
+
+.openapi-import-header p {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 14px;
+}
+
+.openapi-import-body {
+  overflow: auto;
+  padding: 20px 24px 24px;
+  background: var(--bg-canvas);
+}
+
+.openapi-import-upload {
+  display: grid;
+  gap: 12px;
+  padding: 16px;
+  border: 1px solid var(--border-subtle);
+  border-radius: 16px;
+  background: var(--bg-surface);
+}
+
+.openapi-file-label {
+  display: grid;
+  gap: 8px;
+  color: var(--text-secondary);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+#openapi-import-document {
+  min-height: 132px;
+  max-height: 34vh;
+  resize: vertical;
+  padding: 14px;
+  border: 1px solid var(--border);
+  border-radius: 14px;
+  background: #0d1117;
+  color: var(--text-primary);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.55;
+}
+
+#openapi-import-file {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  clip-path: inset(50%);
+  white-space: nowrap;
+}
+
+.openapi-file-control {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-width: 0;
+}
+
+.openapi-file-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 32px;
+  cursor: pointer;
+}
+
+.openapi-file-name {
+  overflow: hidden;
+  color: var(--text-muted);
+  font-size: 13px;
+  font-weight: 500;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.openapi-import-actions,
+.openapi-import-footer {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.openapi-import-status {
+  margin-top: 14px;
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+
+.openapi-import-status.error {
+  color: var(--red);
+}
+
+.openapi-import-preview {
+  display: grid;
+  gap: 16px;
+  margin-top: 18px;
+}
+
+.openapi-import-source,
+.openapi-import-group {
+  border: 1px solid var(--border);
+  border-radius: 16px;
+  background: var(--bg-overlay);
+}
+
+.openapi-import-source {
+  padding: 14px 16px;
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+
+.openapi-import-server-row {
+  display: grid;
+  gap: 8px;
+}
+
+.openapi-import-server-row label {
+  color: var(--text-secondary);
+  font-size: 13px;
+  font-weight: 700;
+}
+
+#openapi-import-server,
+#openapi-import-conflict-mode,
+#openapi-import-search,
+#openapi-import-method-filter,
+.openapi-import-server-custom {
+  max-width: 520px;
+  padding: 10px 12px;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: var(--bg-surface);
+  color: var(--text-primary);
+}
+
+.openapi-import-toolbar {
+  display: grid;
+  grid-template-columns: minmax(220px, 1fr) minmax(160px, 220px) auto;
+  gap: 12px;
+  align-items: end;
+  padding: 14px 16px;
+  border: 1px solid var(--border);
+  border-radius: 16px;
+  background: var(--bg-overlay);
+}
+
+.openapi-import-filter {
+  display: grid;
+  gap: 8px;
+}
+
+.openapi-import-filter label {
+  color: var(--text-secondary);
+  font-size: 12px;
+  font-weight: 800;
+}
+
+#openapi-import-search,
+#openapi-import-method-filter {
+  width: 100%;
+  max-width: none;
+  background: var(--bg-surface);
+}
+
+.openapi-import-bulk-actions {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.openapi-import-groups {
+  display: grid;
+  gap: 14px;
+}
+
+.openapi-import-group-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 14px 16px;
+  border-bottom: 1px solid var(--border);
+  font-weight: 800;
+}
+
+.openapi-import-group-count {
+  margin-left: auto;
+  color: var(--text-secondary);
+  font-size: 12px;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
+.openapi-import-group-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-secondary);
+  font-size: 12px;
+  font-weight: 700;
+}
+
+.openapi-import-operation {
+  display: grid;
+  grid-template-columns: auto 1fr auto;
+  gap: 12px;
+  align-items: start;
+  padding: 14px 16px;
+  border-bottom: 1px solid var(--border);
+}
+
+.openapi-import-operation:last-child {
+  border-bottom: 0;
+}
+
+.openapi-import-operation-title {
+  font-weight: 800;
+}
+
+.openapi-import-operation-meta {
+  margin-top: 4px;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+.openapi-import-method {
+  padding: 4px 8px;
+  border-radius: 999px;
+  background: var(--accent-glow);
+  color: var(--accent);
+  font-size: 11px;
+  font-weight: 800;
+}
+
+.openapi-import-findings {
+  grid-column: 2 / -1;
+  display: grid;
+  gap: 4px;
+  font-size: 12px;
+}
+
+.openapi-import-finding {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 6px;
+  color: var(--amber);
+  line-height: 1.45;
+}
+
+.openapi-import-finding-info {
+  color: var(--blue);
+}
+
+.openapi-import-finding-error {
+  color: var(--red);
+}
+
+.openapi-import-finding strong {
+  font-weight: 900;
+}
+
+.openapi-import-mapping-preview {
+  grid-column: 2 / -1;
+  display: grid;
+  gap: 8px;
+  padding: 10px 12px;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: var(--bg-surface);
+}
+
+.openapi-import-mapping-group {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
+.openapi-import-mapping-label {
+  min-width: 52px;
+  color: var(--text-secondary);
+  font-size: 11px;
+  font-weight: 800;
+  text-transform: uppercase;
+}
+
+.openapi-import-mapping-chip {
+  padding: 3px 7px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  background: var(--bg-overlay);
+  color: var(--text-primary);
+  font-size: 11px;
+}
+
+.openapi-import-mapping-more {
+  color: var(--text-secondary);
+  font-size: 11px;
+  font-weight: 800;
+}
+
+.openapi-import-document-findings,
+.openapi-import-result {
+  display: grid;
+  gap: 8px;
+  padding: 14px 16px;
+  border: 1px solid var(--border);
+  border-radius: 16px;
+  background: var(--bg-overlay);
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+
+.openapi-import-result strong {
+  color: var(--text-primary);
+}
+
+.openapi-import-primary-result {
+  display: flex;
+  justify-content: flex-start;
+  margin: 4px 0;
+}
+
+.openapi-import-primary-result .btn-primary {
+  text-decoration: none;
+}
+
+.openapi-import-result-table {
+  display: grid;
+  gap: 0;
+  overflow: hidden;
+  border: 1px solid var(--border);
+  border-radius: 14px;
+  background: var(--bg-surface);
+}
+
+.openapi-import-result-row {
+  display: grid;
+  grid-template-columns: minmax(180px, 0.9fr) minmax(260px, 1.5fr) auto;
+  gap: 12px;
+  align-items: start;
+  padding: 12px 14px;
+  border-bottom: 1px solid var(--border);
+}
+
+.openapi-import-result-row:last-child {
+  border-bottom: 0;
+}
+
+.openapi-import-result-head {
+  color: var(--text-secondary);
+  font-size: 11px;
+  font-weight: 900;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  background: var(--bg-overlay);
+}
+
+.openapi-import-result-name {
+  color: var(--text-primary);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.openapi-import-result-meta {
+  margin-top: 4px;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+.openapi-import-result-findings {
+  display: grid;
+  gap: 5px;
+}
+
+.openapi-import-result-ok {
+  color: var(--green);
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.openapi-import-result-more {
+  color: var(--text-secondary);
+  font-size: 12px;
+  font-weight: 800;
+}
+
+.openapi-import-result-action {
+  white-space: nowrap;
+  text-decoration: none;
+}
+
+.openapi-import-result-skipped {
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+
+.openapi-import-created-list {
+  display: grid;
+  gap: 6px;
+  margin: 4px 0 0;
+  padding: 0;
+  list-style: none;
+}
+
+.openapi-import-created-list a {
+  color: var(--accent);
+  font-weight: 700;
+  text-decoration: none;
+}
+
+@media (max-width: 720px) {
+  .openapi-import-toolbar {
+    grid-template-columns: 1fr;
+  }
+
+  .openapi-import-bulk-actions {
+    justify-content: flex-start;
+  }
+
+  .openapi-import-operation {
+    grid-template-columns: auto 1fr;
+  }
+
+  .openapi-import-result-row {
+    grid-template-columns: 1fr;
+  }
+
+  .openapi-import-method {
+    justify-self: start;
+  }
+}

apps/ui/css/wizard.css

@@ -189,6 +189,192 @@
   color: var(--text-primary);
 }
 
+.mapping-builder-card .config-card-header {
+  align-items: flex-start;
+}
+
+.mapping-table {
+  display: grid;
+  gap: 8px;
+}
+
+.mapping-row {
+  display: grid;
+  grid-template-columns:
+    minmax(130px, 1fr)
+    24px
+    minmax(105px, 0.65fr)
+    minmax(130px, 1fr)
+    minmax(120px, 0.8fr)
+    minmax(150px, 0.9fr)
+    34px;
+  gap: 8px;
+  align-items: center;
+  padding: 10px;
+  border: 1px solid var(--border-subtle);
+  border-radius: 10px;
+  background: var(--bg-overlay);
+}
+
+.response-mapping-row {
+  grid-template-columns: minmax(160px, 1fr) 24px minmax(140px, 1fr) 34px;
+}
+
+.mapping-field {
+  display: grid;
+  gap: 5px;
+  min-width: 0;
+}
+
+.mapping-field-label {
+  color: var(--text-muted);
+  font-size: 10.5px;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  line-height: 1;
+  text-transform: uppercase;
+}
+
+.mapping-arrow {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  align-self: end;
+  width: 24px;
+  height: 34px;
+  color: var(--accent);
+  font-size: 18px;
+  font-weight: 900;
+  line-height: 1;
+}
+
+.mapping-default-value {
+  border-style: dashed;
+}
+
+.mapping-row-remove {
+  width: 32px;
+  height: 32px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border: 1px solid var(--red-border);
+  border-radius: 8px;
+  background: var(--red-bg);
+  color: var(--red);
+  font-size: 18px;
+  line-height: 1;
+  font-weight: 800;
+  transition: background 0.15s, border-color 0.15s, color 0.15s, transform 0.15s;
+}
+
+.mapping-row-remove:hover {
+  border-color: rgba(248, 81, 73, 0.45);
+  background: rgba(248, 81, 73, 0.16);
+  color: #ff7b72;
+  transform: translateY(-1px);
+}
+
+.mapping-builder-actions {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.advanced-mapping-details {
+  border: 1px solid var(--border-subtle);
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.02);
+  overflow: hidden;
+}
+
+.advanced-mapping-details summary {
+  padding: 10px 12px;
+  cursor: pointer;
+  color: var(--text-secondary);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.advanced-mapping-details[open] summary {
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.mapping-response-layout {
+  display: grid;
+  grid-template-columns: minmax(220px, 0.85fr) minmax(320px, 1.15fr);
+  gap: 14px;
+  align-items: start;
+}
+
+.json-tree-picker {
+  display: grid;
+  gap: 6px;
+  max-height: 320px;
+  overflow: auto;
+  padding: 10px;
+  border: 1px solid var(--border-subtle);
+  border-radius: 10px;
+  background: var(--bg-overlay);
+}
+
+.json-tree-node {
+  width: 100%;
+  text-align: left;
+  border: 1px solid transparent;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--text-secondary);
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 12px;
+  padding: 7px 9px;
+  cursor: pointer;
+}
+
+.json-tree-node:hover {
+  border-color: var(--border);
+  background: var(--bg-surface);
+  color: var(--text-primary);
+}
+
+.mapping-warnings {
+  display: grid;
+  gap: 8px;
+  margin-bottom: 20px;
+}
+
+.mapping-warning {
+  padding: 10px 12px;
+  border: 1px solid rgba(245, 158, 11, 0.34);
+  border-radius: 10px;
+  background: rgba(245, 158, 11, 0.1);
+  color: var(--text-secondary);
+  font-size: 13px;
+  line-height: 1.45;
+}
+
+.mapping-warning strong {
+  color: var(--text-primary);
+}
+
+@media (max-width: 900px) {
+  .mapping-row,
+  .response-mapping-row,
+  .mapping-response-layout {
+    grid-template-columns: 1fr;
+  }
+
+  .mapping-arrow {
+    width: 100%;
+    height: 18px;
+    transform: rotate(90deg);
+  }
+
+  .mapping-row-remove {
+    width: 100%;
+  }
+}
+
 /* ══════════════════════════════════════════════════
    STEP SIDEBAR
 ══════════════════════════════════════════════════ */
@@ -927,6 +1113,31 @@
 .toggle-label { font-size: 13px; font-weight: 500; color: var(--text-primary); }
 .toggle-desc  { font-size: 11.5px; color: var(--text-muted); margin-top: 1px; }
 
+.approval-toggle-row {
+  position: relative;
+}
+
+.approval-toggle-input {
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.approval-config-fields {
+  display: grid;
+  gap: 16px;
+  padding: 16px;
+  border: 1px solid var(--border-subtle);
+  border-radius: 10px;
+  background: rgba(13, 17, 23, 0.42);
+}
+
+.approval-preview-pill {
+  align-self: end;
+  min-height: 38px;
+  justify-content: center;
+}
+
 /* ══════════════════════════════════════════════════
    BOTTOM ACTION BAR — frosted dark glass
 ══════════════════════════════════════════════════ */
@@ -1119,6 +1330,18 @@
   box-shadow: none !important;
 }
 
+.form-group > .code-textarea {
+  border: 1px solid var(--border) !important;
+  border-radius: 8px !important;
+  background: #0d1117 !important;
+  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.015);
+}
+
+.form-group > .code-textarea:focus {
+  border-color: var(--accent) !important;
+  box-shadow: 0 0 0 3px var(--accent-ring), inset 0 0 0 1px rgba(255, 255, 255, 0.02) !important;
+}
+
 /* ── Section divider ── */
 .section-divider {
   display: flex;
@@ -1527,6 +1750,16 @@
   margin-top: 6px;
 }
 
+.quality-finding-jump {
+  margin-top: 8px;
+}
+
+.quality-focus-target {
+  outline: 2px solid rgba(13, 148, 136, 0.85);
+  box-shadow: 0 0 0 4px rgba(13, 148, 136, 0.14);
+  transition: box-shadow 0.2s ease, outline-color 0.2s ease;
+}
+
 @media (max-width: 760px) {
   .agent-preview-summary {
     grid-template-columns: 1fr;

apps/ui/html/api-keys.html

@@ -23,9 +23,75 @@
   .scope-checkbox-name { font-size: 13px; font-weight: 500; color: var(--text-primary); }
   .scope-checkbox-desc { font-size: 11.5px; color: var(--text-muted); }
   .keys-card-list { display: none; }
+  .key-kind-tabs {
+    display: inline-flex;
+    gap: 4px;
+    padding: 4px;
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    background: var(--bg-overlay);
+  }
+  .key-kind-tab {
+    border: 0;
+    border-radius: var(--radius);
+    background: transparent;
+    color: var(--text-secondary);
+    padding: 7px 12px;
+    font-size: 13px;
+    font-weight: 600;
+  }
+  .key-kind-tab.active {
+    background: var(--accent);
+    color: #fff;
+  }
+  .key-kind-header-control {
+    display: grid;
+    grid-template-columns: auto auto;
+    align-items: center;
+    gap: 10px;
+    justify-content: space-between;
+    width: 100%;
+  }
+  .key-kind-header-hint {
+    grid-column: 1 / -1;
+    max-width: 520px;
+    margin: 0;
+    text-align: left;
+  }
+  .api-keys-page-header {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 14px;
+  }
+  .api-keys-page-header .page-header-text {
+    max-width: 680px;
+  }
+  .api-keys-page-header .page-header-actions {
+    width: 100%;
+  }
+  .approval-warning-callout {
+    display: flex;
+    gap: 10px;
+    padding: 12px 14px;
+    border: 1px solid var(--amber-border);
+    border-radius: var(--radius-lg);
+    background: var(--amber-bg);
+    color: var(--text-primary);
+    font-size: 13px;
+    line-height: 1.55;
+  }
+  .approval-warning-callout svg {
+    color: var(--amber);
+    flex: 0 0 auto;
+    margin-top: 2px;
+  }
   @media (max-width: 720px) {
     #keys-table-wrap { display: none; }
     .keys-card-list { display: grid; }
+    .key-kind-header-control { grid-template-columns: 1fr; justify-content: stretch; width: 100%; }
+    .key-kind-tabs { width: 100%; }
+    .key-kind-tab { flex: 1; }
+    .key-kind-header-hint { text-align: left; }
   }
   </style>
   <script src="%CRANK_BUNDLE_PROTECTED_CORE%"></script>
@@ -94,16 +160,23 @@
   <!-- ═══════════════════ PAGE ═══════════════════ -->
   <div class="page">
 
-    <div class="page-header">
+    <div class="page-header api-keys-page-header">
       <div class="page-header-text">
         <h1 class="page-title" data-i18n="apikeys.title">Agent Keys</h1>
         <p class="page-subtitle" data-i18n="apikeys.subtitle">These keys connect an MCP client to the MCP server and are issued for a specific agent.</p>
       </div>
       <div class="page-header-actions">
-        <button class="btn-primary" id="btn-create-key" type="button">
-          <svg width="13" height="13" viewBox="0 0 16 16" fill="currentColor"><path d="M7.75 2a.75.75 0 01.75.75V7h4.25a.75.75 0 010 1.5H8.5v4.25a.75.75 0 01-1.5 0V8.5H2.75a.75.75 0 010-1.5H7V2.75A.75.75 0 017.75 2z"/></svg>
-          <span data-i18n="apikeys.new">Create key</span>
-        </button>
+        <div class="key-kind-header-control">
+          <div class="key-kind-tabs" role="tablist" aria-label="Key type">
+            <button class="key-kind-tab active" id="key-kind-mcp-client" type="button" data-key-kind="mcp_client" data-i18n="apikeys.kind.mcp">MCP clients</button>
+            <button class="key-kind-tab" id="key-kind-approval" type="button" data-key-kind="approval" data-i18n="apikeys.kind.approval">Approvals</button>
+          </div>
+          <button class="btn-primary" id="btn-create-key" type="button">
+            <svg width="13" height="13" viewBox="0 0 16 16" fill="currentColor"><path d="M7.75 2a.75.75 0 01.75.75V7h4.25a.75.75 0 010 1.5H8.5v4.25a.75.75 0 01-1.5 0V8.5H2.75a.75.75 0 010-1.5H7V2.75A.75.75 0 017.75 2z"/></svg>
+            <span id="btn-create-key-label" data-i18n="apikeys.new">Create key</span>
+          </button>
+          <div class="field-hint key-kind-header-hint" id="key-kind-hint"></div>
+        </div>
       </div>
     </div>
 
@@ -170,25 +243,7 @@
       <div class="section-card-header">
           <div class="section-card-title" data-i18n="apikeys.scope_ref">Access reference</div>
       </div>
-      <div class="section-card-body" style="display:grid;grid-template-columns:repeat(3,1fr);gap:12px;">
-        <div>
-          <div style="font-size:12.5px;font-weight:600;color:var(--text-primary);margin-bottom:4px;display:flex;align-items:center;gap:6px;">
-            <span class="badge badge-scope">read</span>
-          </div>
-          <div style="font-size:12px;color:var(--text-muted);line-height:1.55;" data-i18n="apikeys.scope.read">Initialize MCP sessions, ping the server, and list tools for a workspace agent.</div>
-        </div>
-        <div>
-          <div style="font-size:12.5px;font-weight:600;color:var(--text-primary);margin-bottom:4px;">
-            <span class="badge badge-scope">write</span>
-          </div>
-          <div style="font-size:12px;color:var(--text-muted);line-height:1.55;" data-i18n="apikeys.scope.write">Execute `tools/call` requests against published agent toolsets.</div>
-        </div>
-        <div>
-          <div style="font-size:12.5px;font-weight:600;color:var(--text-primary);margin-bottom:4px;">
-            <span class="badge badge-scope">deploy</span>
-          </div>
-          <div style="font-size:12px;color:var(--text-muted);line-height:1.55;" data-i18n="apikeys.scope.deploy">Reserved for deploy-scoped automation. Today it also permits MCP read/write flows.</div>
-        </div>
+      <div class="section-card-body" id="scope-reference-grid" style="display:grid;grid-template-columns:repeat(3,1fr);gap:12px;">
       </div>
     </div>
 
@@ -198,7 +253,7 @@
   <div class="modal-overlay" id="modal-create">
     <div class="modal">
       <div class="modal-header">
-        <span class="modal-title" data-i18n="apikeys.modal.title">Create agent key</span>
+        <span class="modal-title" id="modal-create-title" data-i18n="apikeys.modal.title">Create agent key</span>
         <button class="modal-close" id="modal-close-btn" type="button">
           <svg width="12" height="12" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round">
             <line x1="1" y1="1" x2="11" y2="11"/><line x1="11" y1="1" x2="1" y2="11"/>
@@ -211,6 +266,12 @@
           <input class="field-input" id="new-key-name" type="text" data-i18n-ph="apikeys.modal.name_placeholder" placeholder="e.g. Production, CI pipeline" autocomplete="off">
           <div class="field-hint" data-i18n="apikeys.modal.name_hint">A descriptive label to identify the key. Only visible to admins.</div>
         </div>
+        <div class="approval-warning-callout" id="approval-key-warning" hidden>
+          <svg width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+            <polygon points="8,1.5 15.5,14.5 0.5,14.5" fill="none"/><path d="M8 6v4M8 11.5v.5"/>
+          </svg>
+          <div data-i18n="apikeys.approval.warning">Do not pass this key to an LLM or MCP client. It is only for an external interface where a human confirms an action.</div>
+        </div>
         <div class="field-group" style="margin-bottom:0;">
           <label class="field-label" data-i18n="apikeys.modal.scopes">Access</label>
           <div style="display:flex;flex-direction:column;gap:8px;margin-top:2px;" id="scope-checkboxes">

apps/ui/html/logs.html

@@ -78,6 +78,20 @@
       </div>
     </div>
 
+    <div class="section-card approval-panel">
+      <div class="approval-panel-header">
+        <div>
+          <div class="approval-panel-title" data-i18n="approvals.title">Human confirmations</div>
+          <div class="approval-panel-subtitle" data-i18n="approvals.subtitle">Requests waiting for an external user decision and recent results.</div>
+        </div>
+        <button class="refresh-btn approval-refresh-btn" id="approval-refresh-btn" type="button">
+          <svg width="12" height="12" viewBox="0 0 16 16" fill="currentColor"><path d="M1.705 8.005a.75.75 0 01.834.656 5.5 5.5 0 009.592 2.97l-1.204-1.204a.25.25 0 01.177-.427h3.646a.25.25 0 01.25.25v3.646a.25.25 0 01-.427.177l-1.38-1.38A7.001 7.001 0 011.05 8.84a.75.75 0 01.656-.834zM8 2.5a5.487 5.487 0 00-4.131 1.869l1.204 1.204A.25.25 0 014.896 6H1.25A.25.25 0 011 5.75V2.104a.25.25 0 01.427-.177l1.38 1.38A7.001 7.001 0 0114.95 7.16a.75.75 0 01-1.49.178A5.501 5.501 0 008 2.5z"/></svg>
+          <span data-i18n="approvals.refresh">Refresh</span>
+        </button>
+      </div>
+      <div class="approval-list" id="approval-list"></div>
+    </div>
+
     <div class="section-card">
       <div class="log-toolbar">
         <div class="live-dot"></div>

apps/ui/html/wizard/step3-rest.html

@@ -90,4 +90,92 @@
             </div>
           </div>
 
+          <div class="config-card approval-gate-card" style="margin-bottom: 20px;">
+            <div class="config-card-header">
+              <div class="config-card-header-icon">
+                <svg width="13" height="13" viewBox="0 0 16 16" fill="none" stroke="var(--text-secondary)" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+                  <path d="M8 2l5 2v4c0 3-2 5-5 6-3-1-5-3-5-6V4l5-2z"/>
+                  <path d="M6 8l1.4 1.4L10.5 6"/>
+                </svg>
+              </div>
+              <div>
+                <div class="config-card-title" data-i18n="wizard.approval.title">Подтверждение человеком</div>
+                <div class="config-card-subtitle" data-i18n="wizard.approval.subtitle">Включайте для действий, которые нельзя выполнять без явного решения пользователя.</div>
+              </div>
+            </div>
+            <div class="config-card-body" style="gap: 16px;">
+              <label class="toggle-row approval-toggle-row" for="approval-required">
+                <span id="approval-required-toggle" class="toggle" aria-hidden="true"></span>
+                <span class="toggle-text">
+                  <span class="toggle-label" data-i18n="wizard.approval.required_label">Требовать подтверждение перед выполнением</span>
+                  <span class="toggle-desc" data-i18n="wizard.approval.required_desc">MCP клиент получит ожидающий запрос, а действие выполнится только после подтверждения через отдельный эндпоинт подтверждения.</span>
+                </span>
+                <input id="approval-required" type="checkbox" class="approval-toggle-input">
+              </label>
+
+              <div id="approval-config-fields" class="approval-config-fields" hidden>
+                <div class="form-group">
+                  <label class="form-label" for="approval-mode" data-i18n="wizard.approval.mode">Механизм подтверждения</label>
+                  <select id="approval-mode" class="form-select">
+                    <option value="custom" data-i18n="wizard.approval.mode.custom">Custom MCP Approval</option>
+                    <option value="elicitation" data-i18n="wizard.approval.mode.elicitation">MCP Elicitation</option>
+                  </select>
+                </div>
+
+                <div class="info-callout" id="approval-custom-info">
+                  <svg class="info-callout-icon" width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="var(--accent)" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+                    <circle cx="8" cy="8" r="6.5"></circle>
+                    <path d="M8 11V8M8 5.5V5"></path>
+                  </svg>
+                  <div class="info-callout-body">
+                    <div class="info-callout-title" data-i18n="wizard.approval.custom_title">Custom MCP Approval</div>
+                    <div class="info-callout-text" data-i18n="wizard.approval.custom_body">Crank вернёт MCP-клиенту ответ о необходимости подтверждения, идентификатор заявки и адреса для подтверждения или отказа. Ваш MCP-клиент должен распознать такой ответ, показать пользователю окно подтверждения и отправить решение на адрес подтверждения. Для этого адреса нужен отдельный ключ подтверждения агента.</div>
+                  </div>
+                </div>
+
+                <div class="info-callout" id="approval-elicitation-info" hidden>
+                  <svg class="info-callout-icon" width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="var(--accent)" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+                    <circle cx="8" cy="8" r="6.5"></circle>
+                    <path d="M8 11V8M8 5.5V5"></path>
+                  </svg>
+                  <div class="info-callout-body">
+                    <div class="info-callout-title" data-i18n="wizard.approval.elicitation_title">MCP Elicitation</div>
+                    <div class="info-callout-text" data-i18n="wizard.approval.elicitation_body">Crank запросит подтверждение стандартным способом MCP Elicitation. MCP-клиент должен поддерживать эту возможность. Отдельный ключ подтверждения не используется: решение пользователя возвращается по текущему MCP-подключению.</div>
+                  </div>
+                </div>
+
+                <div class="form-group" id="approval-elicitation-message-group" hidden>
+                  <label class="form-label" for="approval-elicitation-message" data-i18n="wizard.approval.elicitation_message">Сообщение для MCP-клиента</label>
+                  <textarea id="approval-elicitation-message" class="form-textarea" rows="3" maxlength="240" data-i18n-ph="wizard.approval.elicitation_message_placeholder" placeholder="Подтвердите выполнение операции."></textarea>
+                  <div class="form-hint" data-i18n="wizard.approval.elicitation_message_hint">Короткое сообщение для MCP-клиента. Внешний вид окна подтверждения определяет сам клиент.</div>
+                </div>
+
+                <div class="form-group">
+                  <label class="form-label" for="approval-ttl-seconds" data-i18n="wizard.approval.ttl">Сколько ждать подтверждение</label>
+                  <select id="approval-ttl-seconds" class="form-select">
+                    <option value="60">1 минута</option>
+                    <option value="180">3 минуты</option>
+                    <option value="300" selected>5 минут</option>
+                  </select>
+                </div>
+
+                <label class="checkbox-pill approval-preview-pill">
+                  <input id="approval-show-payload-preview" type="checkbox" checked>
+                  <span data-i18n="wizard.approval.show_payload">Передавать параметры вызова в подтверждение</span>
+                </label>
+
+                <div class="info-callout" id="approval-payload-info">
+                  <svg class="info-callout-icon" width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="var(--accent)" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+                    <circle cx="8" cy="8" r="6.5"></circle>
+                    <path d="M8 11V8M8 5.5V5"></path>
+                  </svg>
+                  <div class="info-callout-body">
+                    <div class="info-callout-title" data-i18n="wizard.approval.payload_title">Параметры подтверждения</div>
+                    <div class="info-callout-text" data-i18n="wizard.approval.payload_body">Если включено, Crank передаст параметры вызова вместе с запросом подтверждения. Так внешний интерфейс или MCP-клиент сможет показать пользователю, какое действие он подтверждает. Если параметры содержат чувствительные данные, выключите эту опцию.</div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+
         </div><!-- /step-pane-3-rest -->

apps/ui/html/wizard/step5.html

@@ -13,20 +13,35 @@
             <div class="section-divider-line"></div>
           </div>
 
-          <div class="config-card" style="margin-bottom: 20px;">
-            <div class="config-card-body" style="gap: 0; padding: 0;">
-              <div class="code-block" style="border-radius: 0; border: none;">
-                <div class="code-toolbar">
-                  <div class="code-dots"><span></span><span></span><span></span></div>
-                  <span class="code-toolbar-label">yaml / request-fields</span>
-                </div>
-                <textarea id="tool-input-mapping" class="form-textarea code-textarea" rows="12">first_name: "$.input.first_name"
+          <div class="config-card mapping-builder-card" style="margin-bottom: 20px;">
+            <div class="config-card-header">
+              <div>
+                <div class="config-card-title">Конструктор API-запроса</div>
+                <div class="config-card-subtitle">Укажите, куда отправлять поля инструмента: в путь, query-параметры, заголовки или JSON-тело.</div>
+              </div>
+              <button id="wizard-add-request-mapping-row" class="btn-ghost-sm" type="button">Добавить поле</button>
+            </div>
+            <div class="config-card-body" style="gap: 14px;">
+              <div class="mapping-table" id="wizard-request-mapping-rows" data-testid="wizard-request-mapping-rows"></div>
+              <div class="mapping-builder-actions">
+                <button id="wizard-auto-request-mapping" class="btn-ghost-sm" type="button">Собрать из входного JSON</button>
+                <button id="wizard-sync-request-mapping" class="btn-ghost-sm" type="button">Обновить YAML</button>
+              </div>
+              <details class="advanced-mapping-details">
+                <summary>Дополнительно: YAML маппинга запроса</summary>
+                <div class="code-block">
+                  <div class="code-toolbar">
+                    <div class="code-dots"><span></span><span></span><span></span></div>
+                    <span class="code-toolbar-label">yaml / request-fields</span>
+                  </div>
+                  <textarea id="tool-input-mapping" class="form-textarea code-textarea" rows="10">first_name: "$.input.first_name"
 last_name:  "$.input.last_name"
 email:      "$.input.email"
 company:    "$.input.company"
 phone:      "$.input.phone"
 source:     "$.input.source"</textarea>
-              </div>
+                </div>
+              </details>
             </div>
           </div>
 
@@ -35,18 +50,42 @@ source:     "$.input.source"</textarea>
             <div class="section-divider-line"></div>
           </div>
 
-          <div class="config-card" style="margin-bottom: 20px;">
-            <div class="config-card-body" style="gap: 0; padding: 0;">
-              <div class="code-block" style="border-radius: 0; border: none;">
-                <div class="code-toolbar">
-                  <div class="code-dots"><span></span><span></span><span></span></div>
-                  <span class="code-toolbar-label">yaml / response-fields</span>
+          <div class="config-card mapping-builder-card" style="margin-bottom: 20px;">
+            <div class="config-card-header">
+              <div>
+                <div class="config-card-title">Конструктор ответа инструмента</div>
+                <div class="config-card-subtitle">Выберите поля из ответа API, которые нужно вернуть MCP клиенту.</div>
+              </div>
+              <button id="wizard-add-response-mapping-row" class="btn-ghost-sm" type="button">Добавить поле</button>
+            </div>
+            <div class="config-card-body" style="gap: 14px;">
+              <div class="mapping-response-layout">
+                <div>
+                  <div class="form-label">Поля ответа API</div>
+                  <div id="wizard-response-json-tree" class="json-tree-picker" data-testid="wizard-response-json-tree"></div>
                 </div>
-                <textarea id="tool-output-mapping" class="form-textarea code-textarea" rows="10">lead_id:    "$.response.data.id"
+                <div>
+                  <div class="form-label">Поля результата инструмента</div>
+                  <div class="mapping-table" id="wizard-response-mapping-rows" data-testid="wizard-response-mapping-rows"></div>
+                </div>
+              </div>
+              <div class="mapping-builder-actions">
+                <button id="wizard-auto-response-mapping" class="btn-ghost-sm" type="button">Собрать из ответа JSON</button>
+                <button id="wizard-sync-response-mapping" class="btn-ghost-sm" type="button">Обновить YAML</button>
+              </div>
+              <details class="advanced-mapping-details">
+                <summary>Дополнительно: YAML маппинга ответа</summary>
+                <div class="code-block">
+                  <div class="code-toolbar">
+                    <div class="code-dots"><span></span><span></span><span></span></div>
+                    <span class="code-toolbar-label">yaml / response-fields</span>
+                  </div>
+                  <textarea id="tool-output-mapping" class="form-textarea code-textarea" rows="10">lead_id:    "$.response.data.id"
 status:     "$.response.data.status"
 created_at: "$.response.data.created_at"
 owner_id:   "$.response.data.owner.id"</textarea>
-              </div>
+                </div>
+              </details>
             </div>
           </div>
 
@@ -103,6 +142,8 @@ tls:
             </div>
           </div>
 
+          <div id="wizard-mapping-warnings" class="mapping-warnings" hidden data-testid="wizard-mapping-warnings"></div>
+
           <div class="config-card" id="agent-facing-preview-card" style="margin-bottom: 20px;">
             <div class="config-card-header">
               <div class="config-card-header-icon">
@@ -196,6 +237,7 @@ tls:
   "last_name": "Lovelace",
   "email": "ada@example.com"
 }</textarea>
+                  <input id="wizard-input-sample-file" type="file" accept=".json,application/json" hidden>
                 </div>
                 <div class="form-group">
                   <label class="form-label" data-i18n="wizard.step5.output_sample">Пример ответа</label>
@@ -203,9 +245,13 @@ tls:
   "id": "lead_123",
   "status": "created"
 }</textarea>
+                  <input id="wizard-output-sample-file" type="file" accept=".json,application/json" hidden>
                 </div>
               </div>
               <div style="display:flex; gap: 8px; flex-wrap: wrap;">
+                <button id="wizard-load-input-sample-file" class="btn-ghost-sm" type="button">Загрузить JSON запроса</button>
+                <button id="wizard-load-output-sample-file" class="btn-ghost-sm" type="button">Загрузить JSON ответа</button>
+                <button id="wizard-format-samples" class="btn-ghost-sm" type="button">Проверить и форматировать JSON</button>
                 <button id="wizard-upload-input-sample" class="btn-primary-sm" type="button" data-i18n="wizard.step5.save_input_sample">Сохранить входной пример</button>
                 <button id="wizard-upload-output-sample" class="btn-ghost-sm" type="button" data-i18n="wizard.step5.save_output_sample">Сохранить выходной пример</button>
                 <button id="wizard-generate-draft" class="btn-ghost-sm" type="button" data-i18n="wizard.step5.generate_draft">Пересобрать по примерам</button>

apps/ui/index.html

@@ -9,6 +9,7 @@
   <link rel="stylesheet" href="css/layout.css">
   <link rel="stylesheet" href="css/catalog.css">
   <link rel="stylesheet" href="css/pages.css">
+  <link rel="stylesheet" href="css/openapi-import.css">
   <script src="%CRANK_BUNDLE_PROTECTED_CORE%"></script>
 </head>
 <body x-data="catalog()">
@@ -88,10 +89,16 @@
         <h1 class="page-heading" data-i18n="ops.title">Operations</h1>
         <p class="page-subheading" data-i18n="ops.subtitle">Catalog of tools. List of created MCP tools for API endpoints.</p>
       </div>
-      <button class="btn-new" @click="handleNewOperation()">
-        <svg width="13" height="13"><use href="icons/general/plus.svg#icon"/></svg>
-        <span data-i18n="ops.new">New operation</span>
-      </button>
+      <div class="page-header-actions">
+        <button class="btn-secondary openapi-import-trigger" @click="handleOpenApiImport()">
+          <svg width="13" height="13"><use href="icons/wizard/upload.svg#icon"/></svg>
+          <span>Импорт OpenAPI</span>
+        </button>
+        <button class="btn-new" @click="handleNewOperation()">
+          <svg width="13" height="13"><use href="icons/general/plus.svg#icon"/></svg>
+          <span data-i18n="ops.new">New operation</span>
+        </button>
+      </div>
     </div>
 
     <!-- Stats -->
@@ -367,6 +374,79 @@
 
   </div><!-- /page -->
 
+  <div class="openapi-import-modal" id="openapi-import-modal" hidden>
+    <div class="openapi-import-backdrop" data-openapi-close></div>
+    <section class="openapi-import-dialog" role="dialog" aria-modal="true" aria-labelledby="openapi-import-title">
+      <div class="openapi-import-header">
+        <div>
+          <h2 id="openapi-import-title">Импорт OpenAPI</h2>
+          <p>Загрузите OpenAPI/Swagger документ, выберите методы и создайте черновики MCP-инструментов.</p>
+        </div>
+        <button class="modal-close" type="button" data-openapi-close aria-label="Закрыть">
+          <svg width="12" height="12" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round">
+            <line x1="1" y1="1" x2="11" y2="11"></line><line x1="11" y1="1" x2="1" y2="11"></line>
+          </svg>
+        </button>
+      </div>
+      <div class="openapi-import-body">
+        <div class="openapi-import-upload">
+          <label class="openapi-file-label">
+            <span>Файл OpenAPI/Swagger</span>
+            <span class="openapi-file-control">
+              <span class="btn-secondary openapi-file-button">Выбрать файл</span>
+              <span class="openapi-file-name" id="openapi-import-file-name">Файл не выбран</span>
+            </span>
+            <input id="openapi-import-file" type="file" accept=".yaml,.yml,.json,application/json,text/yaml">
+          </label>
+          <textarea id="openapi-import-document" spellcheck="false" placeholder="Вставьте openapi.yaml или swagger.json"></textarea>
+          <div class="openapi-import-actions">
+            <button class="btn-primary" id="openapi-import-preview" type="button">Разобрать документ</button>
+            <button class="btn-secondary" id="openapi-import-reset" type="button">Сбросить</button>
+          </div>
+        </div>
+
+        <div class="openapi-import-status" id="openapi-import-status"></div>
+        <div class="openapi-import-preview" id="openapi-import-preview-panel" hidden>
+          <div class="openapi-import-source" id="openapi-import-source"></div>
+          <div class="openapi-import-server-row">
+            <label for="openapi-import-server">Base URL</label>
+            <select id="openapi-import-server"></select>
+            <input id="openapi-import-server-custom" class="openapi-import-server-custom" type="url" placeholder="Или укажите свой base URL, например https://api.example.com">
+          </div>
+          <div class="openapi-import-server-row">
+            <label for="openapi-import-conflict-mode">Если операция уже существует</label>
+            <select id="openapi-import-conflict-mode">
+              <option value="rename" selected>Создать копию с новым именем</option>
+              <option value="skip">Пропустить</option>
+            </select>
+          </div>
+          <div class="openapi-import-toolbar">
+            <div class="openapi-import-filter">
+              <label for="openapi-import-search">Поиск методов</label>
+              <input id="openapi-import-search" type="search" placeholder="Название, operationId или путь">
+            </div>
+            <div class="openapi-import-filter">
+              <label for="openapi-import-method-filter">HTTP-метод</label>
+              <select id="openapi-import-method-filter">
+                <option value="">Все методы</option>
+              </select>
+            </div>
+            <div class="openapi-import-bulk-actions">
+              <button class="btn-secondary" id="openapi-import-select-visible" type="button">Выбрать видимые</button>
+              <button class="btn-secondary" id="openapi-import-clear-visible" type="button">Снять видимые</button>
+            </div>
+          </div>
+          <div class="openapi-import-groups" id="openapi-import-groups"></div>
+          <div class="openapi-import-footer">
+            <span id="openapi-import-selection">Выбрано: 0</span>
+            <button class="btn-primary" id="openapi-import-create" type="button">Создать черновики</button>
+          </div>
+          <div class="openapi-import-result" id="openapi-import-result" hidden></div>
+        </div>
+      </div>
+    </section>
+  </div>
+
   <script src="%CRANK_BUNDLE_OPERATIONS%"></script>
 
 </body>

apps/ui/js/api-keys.js

@@ -2,14 +2,21 @@ var KEYS = [];
 var AGENTS = [];
 var currentWorkspaceId = null;
 var currentAgentId = null;
+var activeKeyKind = 'mcp_client';
 var selectedScopes = new Set(['read']);
 var search = '';
 
-var SCOPES = ['read', 'write', 'deploy'];
+var SCOPES_BY_KIND = {
+  mcp_client: ['read', 'write', 'deploy'],
+  approval: ['read_pending', 'approve', 'deny'],
+};
 var SCOPE_DESC = {
   read: 'apikeys.scope.read',
   write: 'apikeys.scope.write',
   deploy: 'apikeys.scope.deploy',
+  approve: 'apikeys.scope.approve',
+  deny: 'apikeys.scope.deny',
+  read_pending: 'apikeys.scope.read_pending',
 };
 
 function tKey(key) {
@@ -35,6 +42,7 @@ function mapKeyRecord(record) {
   return {
     id: apiKey.id,
     agentId: apiKey.agent_id || null,
+    keyKind: apiKey.key_kind || 'mcp_client',
     name: apiKey.name,
     prefix: apiKey.prefix || '',
     scopes: apiKey.scopes || [],
@@ -173,6 +181,7 @@ async function deleteKey(id) {
 async function createKey(name, scopes) {
   var created = await window.CrankApi.createAgentPlatformApiKey(currentWorkspaceId, currentAgentId, {
     name: name,
+    key_kind: activeKeyKind,
     scopes: scopes,
   });
   return {
@@ -221,13 +230,19 @@ function setCreateButtonState() {
   var button = document.getElementById('btn-create-key');
   if (!button) return;
   button.disabled = !currentAgentId;
+  var label = document.getElementById('btn-create-key-label');
+  if (label) {
+    label.textContent = activeKeyKind === 'approval'
+      ? tKey('apikeys.new_approval')
+      : tKey('apikeys.new_mcp');
+  }
 }
 
 function renderScopes() {
   var el = document.getElementById('scope-checkboxes');
   var tmpl = document.getElementById('tmpl-scope-checkbox');
   el.innerHTML = '';
-  SCOPES.forEach(function(scope) {
+  (SCOPES_BY_KIND[activeKeyKind] || []).forEach(function(scope) {
     var node = tmpl.content.cloneNode(true);
     var input = node.querySelector('input');
     input.dataset.scope = scope;
@@ -242,11 +257,49 @@ function renderScopes() {
   });
 }
 
+function renderKeyKindTabs() {
+  document.querySelectorAll('[data-key-kind]').forEach(function(button) {
+    var kind = button.dataset.keyKind;
+    button.classList.toggle('active', kind === activeKeyKind);
+    button.setAttribute('aria-selected', kind === activeKeyKind ? 'true' : 'false');
+  });
+  var hint = document.getElementById('key-kind-hint');
+  if (hint) {
+    hint.textContent = activeKeyKind === 'approval'
+      ? tKey('apikeys.kind.approval_hint')
+      : tKey('apikeys.kind.mcp_hint');
+  }
+  renderScopeReference();
+  setCreateButtonState();
+}
+
+function renderScopeReference() {
+  var grid = document.getElementById('scope-reference-grid');
+  if (!grid) return;
+  grid.innerHTML = '';
+  (SCOPES_BY_KIND[activeKeyKind] || []).forEach(function(scope) {
+    var item = document.createElement('div');
+    var title = document.createElement('div');
+    title.style.cssText = 'font-size:12.5px;font-weight:600;color:var(--text-primary);margin-bottom:4px;';
+    var badge = document.createElement('span');
+    badge.className = 'badge badge-scope';
+    badge.textContent = scope;
+    title.appendChild(badge);
+    var description = document.createElement('div');
+    description.style.cssText = 'font-size:12px;color:var(--text-muted);line-height:1.55;';
+    description.textContent = tKey(SCOPE_DESC[scope]);
+    item.appendChild(title);
+    item.appendChild(description);
+    grid.appendChild(item);
+  });
+}
+
 function renderTable(errorMessage) {
   var q = search.toLowerCase();
   var tbody = document.getElementById('keys-tbody');
   var cardList = document.getElementById('keys-card-list');
-  var rows = KEYS.filter(function(key) {
+  var visibleKeys = KEYS.filter(function(key) { return key.keyKind === activeKeyKind; });
+  var rows = visibleKeys.filter(function(key) {
     return !q || key.name.toLowerCase().includes(q) || key.prefix.toLowerCase().includes(q);
   });
   var subtitle = document.getElementById('keys-summary-subtitle');
@@ -257,8 +310,8 @@ function renderTable(errorMessage) {
   }
 
   if (subtitle) {
-    var active = KEYS.filter(function(key) { return key.status === 'active'; }).length;
-    var revoked = KEYS.filter(function(key) { return key.status === 'revoked'; }).length;
+    var active = visibleKeys.filter(function(key) { return key.status === 'active'; }).length;
+    var revoked = visibleKeys.filter(function(key) { return key.status === 'revoked'; }).length;
     subtitle.textContent = currentAgentId
       ? tfKey('apikeys.active.subtitle', { active: active, revoked: revoked })
       : tKey('apikeys.agent.empty_hint');
@@ -282,7 +335,7 @@ function renderTable(errorMessage) {
     td.colSpan = 7;
     td.style.cssText = 'text-align:center;padding:36px;color:var(--text-muted);';
     td.textContent = currentAgentId
-      ? (KEYS.length ? tKey('apikeys.empty.search') : tKey('apikeys.empty.none'))
+      ? (visibleKeys.length ? tKey('apikeys.empty.search') : emptyTextForKind())
       : tKey('apikeys.agent.empty_hint');
     empty.appendChild(td);
     tbody.appendChild(empty);
@@ -349,7 +402,7 @@ function renderKeyCards(rows, errorMessage) {
     cardList.appendChild(
       buildKeyCardMessage(
         currentAgentId
-          ? (KEYS.length ? tKey('apikeys.empty.search') : tKey('apikeys.empty.none'))
+          ? (visibleKeys.length ? tKey('apikeys.empty.search') : emptyTextForKind())
           : tKey('apikeys.agent.empty_hint'),
         false
       )
@@ -424,6 +477,12 @@ function buildKeyCardMessage(text, isError) {
   return card;
 }
 
+function emptyTextForKind() {
+  return activeKeyKind === 'approval'
+    ? tKey('apikeys.empty.approval')
+    : tKey('apikeys.empty.none');
+}
+
 function buildMetaItem(labelKey, valueText) {
   var item = document.createElement('div');
   item.className = 'resource-meta-item';
@@ -456,7 +515,11 @@ function openModal() {
   document.getElementById('modal-footer-create').hidden = false;
   document.getElementById('modal-footer-done').hidden = true;
   document.getElementById('new-key-name').value = '';
-  selectedScopes = new Set(['read']);
+  selectedScopes = new Set([activeKeyKind === 'approval' ? 'approve' : 'read']);
+  document.getElementById('modal-create-title').textContent = activeKeyKind === 'approval'
+    ? tKey('apikeys.modal.title_approval')
+    : tKey('apikeys.modal.title_mcp');
+  document.getElementById('approval-key-warning').hidden = activeKeyKind !== 'approval';
   renderScopes();
   modal.classList.add('open');
   setTimeout(function() {
@@ -554,6 +617,16 @@ document.getElementById('agent-select').addEventListener('change', async functio
   await loadKeys();
 });
 
+document.querySelectorAll('[data-key-kind]').forEach(function(button) {
+  button.addEventListener('click', function() {
+    activeKeyKind = this.dataset.keyKind || 'mcp_client';
+    search = '';
+    document.getElementById('key-search').value = '';
+    renderKeyKindTabs();
+    renderTable();
+  });
+});
+
 function copyPrefix(prefix) {
   if (navigator.clipboard) {
     navigator.clipboard.writeText(prefix).catch(function() {});
@@ -564,6 +637,7 @@ function copyPrefix(prefix) {
 }
 
 document.addEventListener('DOMContentLoaded', async function() {
+  renderKeyKindTabs();
   await (window.whenWorkspacesReady ? window.whenWorkspacesReady() : Promise.resolve());
   await loadKeys();
   window.addEventListener('crank:workspacechange', function() {

apps/ui/js/api.js

@@ -244,6 +244,14 @@
         }
       );
     },
+    previewOpenApiImport: function(workspaceId, documentText) {
+      return post('/workspaces/' + encodeURIComponent(workspaceId) + '/imports/openapi/preview', {
+        document: documentText,
+      });
+    },
+    createOpenApiImport: function(workspaceId, jobId, payload) {
+      return post('/workspaces/' + encodeURIComponent(workspaceId) + '/imports/openapi/' + encodeURIComponent(jobId) + '/create', payload);
+    },
     listAgents: function(workspaceId) {
       return get('/workspaces/' + encodeURIComponent(workspaceId) + '/agents');
     },
@@ -319,6 +327,12 @@
     getLog: function(workspaceId, logId) {
       return get('/workspaces/' + encodeURIComponent(workspaceId) + '/logs/' + encodeURIComponent(logId));
     },
+    listApprovals: function(workspaceId, params) {
+      return get('/workspaces/' + encodeURIComponent(workspaceId) + '/approvals' + query(params));
+    },
+    getApproval: function(workspaceId, approvalId) {
+      return get('/workspaces/' + encodeURIComponent(workspaceId) + '/approvals/' + encodeURIComponent(approvalId));
+    },
     getUsageOverview: function(workspaceId, params) {
       return get('/workspaces/' + encodeURIComponent(workspaceId) + '/usage' + query(params));
     },

apps/ui/js/catalog.js

@@ -506,6 +506,15 @@ document.addEventListener('alpine:init', function() {
         window.location.href = (window.CrankRoutes && window.CrankRoutes.wizard) || '/wizard/';
       },
 
+      handleOpenApiImport() {
+        if (window.CrankOpenApiImport) {
+          window.CrankOpenApiImport.open({
+            workspaceId: this.workspaceId,
+            onImported: this.reload.bind(this),
+          });
+        }
+      },
+
       handleLogout() {
         window.CrankAuth.logout();
       },

apps/ui/js/i18n.js

@@ -95,6 +95,12 @@ var TRANSLATIONS = {
     'apikeys.title':    'Agent Keys',
     'apikeys.subtitle': 'These keys connect an MCP client to the MCP server and are issued for a specific agent.',
     'apikeys.new':      'Create key',
+    'apikeys.new_mcp':  'Create MCP client key',
+    'apikeys.new_approval': 'Create approval key',
+    'apikeys.kind.mcp': 'MCP clients',
+    'apikeys.kind.approval': 'Approvals',
+    'apikeys.kind.mcp_hint': 'MCP client keys connect an agent to tools/list and tools/call.',
+    'apikeys.kind.approval_hint': 'Approval keys are used only by an external human confirmation interface.',
     'apikeys.agent.title': 'Agent selection',
     'apikeys.agent.subtitle': 'Select the AI agent this key is issued for.',
     'apikeys.agent.label': 'AI agent',
@@ -118,7 +124,12 @@ var TRANSLATIONS = {
     'apikeys.scope.read': 'Initialize MCP sessions, ping the server, and list tools for the selected AI agent.',
     'apikeys.scope.write': 'Execute `tools/call` requests against published agent toolsets.',
     'apikeys.scope.deploy': 'Reserved for deploy-scoped automation. Today it also permits MCP read/write flows.',
+    'apikeys.scope.approve': 'Confirm a pending human approval request for this agent.',
+    'apikeys.scope.deny': 'Reject a pending human approval request for this agent.',
+    'apikeys.scope.read_pending': 'Read pending human approval requests for this agent.',
     'apikeys.modal.title': 'Create agent key',
+    'apikeys.modal.title_mcp': 'Create MCP client key',
+    'apikeys.modal.title_approval': 'Create approval key',
     'apikeys.modal.name': 'Key name',
     'apikeys.modal.name_hint': 'A descriptive label to identify the key. Only visible to admins.',
     'apikeys.modal.name_placeholder': 'e.g. Production, CI pipeline',
@@ -133,6 +144,7 @@ var TRANSLATIONS = {
     'apikeys.status.revoked': 'Revoked',
     'apikeys.last_used.never': 'Never',
     'apikeys.empty.none': 'No API keys yet',
+    'apikeys.empty.approval': 'No approval keys yet. Create one only if this agent has tools that require human confirmation.',
     'apikeys.empty.search': 'No keys match your search',
     'apikeys.loading': 'Loading…',
     'apikeys.error.api': 'Workspace or API is unavailable',
@@ -160,6 +172,7 @@ var TRANSLATIONS = {
     'apikeys.action.revoke': 'Revoke key',
     'apikeys.action.delete': 'Delete',
     'apikeys.creating': 'Creating…',
+    'apikeys.approval.warning': 'Do not pass this key to an LLM or MCP client. It is only for an external interface where a human confirms an action.',
 
     // Secrets page
     'secrets.title': 'Secrets',
@@ -268,6 +281,27 @@ var TRANSLATIONS = {
     'logs.live.off.body': 'Automatic polling is paused.',
     'logs.refresh.title': 'Logs refreshed',
     'logs.refresh.body': 'The latest invocation records were loaded for the current workspace.',
+    'approvals.title': 'Human confirmations',
+    'approvals.subtitle': 'Requests waiting for an external user decision and recent results.',
+    'approvals.refresh': 'Refresh',
+    'approvals.refresh.title': 'Confirmations refreshed',
+    'approvals.refresh.body': 'The latest confirmation requests were loaded.',
+    'approvals.loading': 'Loading confirmation requests…',
+    'approvals.empty': 'There are no confirmation requests yet.',
+    'approvals.error.load': 'Failed to load confirmation requests',
+    'approvals.untitled': 'Confirmation request',
+    'approvals.operation': 'Operation',
+    'approvals.agent': 'Agent',
+    'approvals.expires_at': 'Expires',
+    'approvals.updated_at': 'Updated',
+    'approvals.request': 'Request',
+    'approvals.response': 'Result',
+    'approvals.status.pending': 'Pending',
+    'approvals.status.approved': 'Approved',
+    'approvals.status.denied': 'Denied',
+    'approvals.status.expired': 'Expired',
+    'approvals.status.completed': 'Completed',
+    'approvals.status.failed': 'Failed',
 
     // Usage page
     'usage.title':      'Usage',
@@ -560,6 +594,24 @@ var TRANSLATIONS = {
     'wizard.step5.execution': 'Execution settings',
     'wizard.step5.exec_title': 'Request execution',
     'wizard.step5.exec_subtitle': 'Timeout, retry count and authorization profile',
+    'wizard.approval.title': 'Human confirmation',
+    'wizard.approval.subtitle': 'Enable this for actions that must not run without an explicit user decision.',
+    'wizard.approval.required_label': 'Require confirmation before execution',
+    'wizard.approval.required_desc': 'The MCP client receives a pending request, and the action runs only after confirmation through a separate approval endpoint.',
+    'wizard.approval.mode': 'Confirmation mechanism',
+    'wizard.approval.mode.custom': 'Custom MCP Approval',
+    'wizard.approval.mode.elicitation': 'MCP Elicitation',
+    'wizard.approval.custom_title': 'Custom MCP Approval',
+    'wizard.approval.custom_body': 'Crank returns approval_required to the MCP client with approval_id, approval_url and approve/deny links. Your MCP client must handle this response, show confirmation to the user and send the decision to the approval endpoint. The approval endpoint requires a separate agent approval key.',
+    'wizard.approval.elicitation_title': 'MCP Elicitation',
+    'wizard.approval.elicitation_body': 'Crank asks for confirmation through standard MCP Elicitation. The MCP client must support the elicitation capability. No separate approval key is used: the user decision returns through the current MCP session.',
+    'wizard.approval.elicitation_message': 'Message for the MCP client',
+    'wizard.approval.elicitation_message_placeholder': 'Confirm operation execution.',
+    'wizard.approval.elicitation_message_hint': 'Short protocol message. The MCP client still controls the confirmation UI.',
+    'wizard.approval.ttl': 'How long to wait for confirmation',
+    'wizard.approval.show_payload': 'Send call parameters to the confirmation flow',
+    'wizard.approval.payload_title': 'Confirmation parameters',
+    'wizard.approval.payload_body': 'When enabled, Crank sends call parameters into the approval flow so the external UI or MCP client can show the user what action is being confirmed. Disable this option if parameters contain sensitive data.',
     'wizard.step5.security_level_title': 'Operation security',
     'wizard.step5.community_security_note': '',
     'wizard.step5.live_title': 'Check and publish',
@@ -905,6 +957,12 @@ var TRANSLATIONS = {
     'apikeys.title':    'Ключи агентов',
     'apikeys.subtitle': 'Эти ключи используются для подключения MCP клиента к MCP серверу и выдаются на конкретного агента.',
     'apikeys.new':      'Создать ключ',
+    'apikeys.new_mcp':  'Создать ключ MCP-клиента',
+    'apikeys.new_approval': 'Создать ключ подтверждения',
+    'apikeys.kind.mcp': 'MCP-клиенты',
+    'apikeys.kind.approval': 'Подтверждения',
+    'apikeys.kind.mcp_hint': 'Ключи MCP-клиентов используются для подключения к tools/list и tools/call агента.',
+    'apikeys.kind.approval_hint': 'Ключи подтверждения используются только внешним интерфейсом, где человек подтверждает действие.',
     'apikeys.agent.title': 'Выбор агента',
     'apikeys.agent.subtitle': 'Выберите AI-агента для которого выпускается ключ.',
     'apikeys.agent.label': 'AI-агент',
@@ -928,7 +986,12 @@ var TRANSLATIONS = {
     'apikeys.scope.read': 'Инициализация MCP-сессий, ping сервера и получение списка инструментов для выбранного AI-агента.',
     'apikeys.scope.write': 'Выполнение `tools/call` для опубликованных наборов инструментов агента.',
     'apikeys.scope.deploy': 'Зарезервировано для deploy-автоматизации. Сейчас также разрешает MCP read/write сценарии.',
+    'apikeys.scope.approve': 'Подтверждение ожидающего запроса для этого агента.',
+    'apikeys.scope.deny': 'Отклонение ожидающего запроса для этого агента.',
+    'apikeys.scope.read_pending': 'Получение списка запросов, ожидающих подтверждения для этого агента.',
     'apikeys.modal.title': 'Создать ключ агента',
+    'apikeys.modal.title_mcp': 'Создать ключ MCP-клиента',
+    'apikeys.modal.title_approval': 'Создать ключ подтверждения',
     'apikeys.modal.name': 'Имя ключа',
     'apikeys.modal.name_hint': 'Понятная метка для идентификации ключа. Видна только администраторам.',
     'apikeys.modal.name_placeholder': 'например, Production, CI pipeline',
@@ -943,6 +1006,7 @@ var TRANSLATIONS = {
     'apikeys.status.revoked': 'Отозван',
     'apikeys.last_used.never': 'Никогда',
     'apikeys.empty.none': 'API-ключей пока нет',
+    'apikeys.empty.approval': 'Ключей подтверждения пока нет. Они нужны только агентам с инструментами, требующими подтверждения человеком.',
     'apikeys.empty.search': 'Нет ключей по текущему поиску',
     'apikeys.loading': 'Загрузка…',
     'apikeys.error.api': 'Воркспейс или API недоступен',
@@ -970,6 +1034,7 @@ var TRANSLATIONS = {
     'apikeys.action.revoke': 'Отозвать ключ',
     'apikeys.action.delete': 'Удалить',
     'apikeys.creating': 'Создание…',
+    'apikeys.approval.warning': 'Не передавайте этот ключ LLM или MCP-клиенту. Он нужен только внешнему интерфейсу, где человек подтверждает действие.',
 
     // Secrets page
     'secrets.title': 'Секреты',
@@ -1080,6 +1145,27 @@ var TRANSLATIONS = {
     'logs.live.off.body': 'Автоматический опрос остановлен.',
     'logs.refresh.title': 'Логи обновлены',
     'logs.refresh.body': 'Получены последние записи вызовов для текущего воркспейса.',
+    'approvals.title': 'Подтверждения человеком',
+    'approvals.subtitle': 'Заявки, которые ожидают решения пользователя, и последние результаты.',
+    'approvals.refresh': 'Обновить',
+    'approvals.refresh.title': 'Подтверждения обновлены',
+    'approvals.refresh.body': 'Получены последние заявки на подтверждение.',
+    'approvals.loading': 'Загрузка заявок на подтверждение…',
+    'approvals.empty': 'Заявок на подтверждение пока нет.',
+    'approvals.error.load': 'Не удалось загрузить заявки на подтверждение',
+    'approvals.untitled': 'Заявка на подтверждение',
+    'approvals.operation': 'Операция',
+    'approvals.agent': 'Агент',
+    'approvals.expires_at': 'Истекает',
+    'approvals.updated_at': 'Обновлено',
+    'approvals.request': 'Запрос',
+    'approvals.response': 'Результат',
+    'approvals.status.pending': 'Ожидает',
+    'approvals.status.approved': 'Подтверждено',
+    'approvals.status.denied': 'Отклонено',
+    'approvals.status.expired': 'Истекло',
+    'approvals.status.completed': 'Выполнено',
+    'approvals.status.failed': 'Ошибка',
 
     // Usage page
     'usage.title':      'Использование',
@@ -1372,6 +1458,24 @@ var TRANSLATIONS = {
     'wizard.step5.execution': 'Параметры выполнения',
     'wizard.step5.exec_title': 'Выполнение запроса',
     'wizard.step5.exec_subtitle': 'Время ожидания, повторные попытки и профиль авторизации',
+    'wizard.approval.title': 'Подтверждение человеком',
+    'wizard.approval.subtitle': 'Включайте для действий, которые нельзя выполнять без явного решения пользователя.',
+    'wizard.approval.required_label': 'Требовать подтверждение перед выполнением',
+    'wizard.approval.required_desc': 'Инструмент не выполнится сразу. Crank сначала запросит подтверждение выбранным способом.',
+    'wizard.approval.mode': 'Механизм подтверждения',
+    'wizard.approval.mode.custom': 'Custom MCP Approval',
+    'wizard.approval.mode.elicitation': 'MCP Elicitation',
+    'wizard.approval.custom_title': 'Custom MCP Approval',
+    'wizard.approval.custom_body': 'Crank вернёт MCP-клиенту ответ о необходимости подтверждения, идентификатор заявки и адреса для подтверждения или отказа. Ваш MCP-клиент должен распознать такой ответ, показать пользователю окно подтверждения и отправить решение на адрес подтверждения. Для этого адреса нужен отдельный ключ подтверждения агента.',
+    'wizard.approval.elicitation_title': 'MCP Elicitation',
+    'wizard.approval.elicitation_body': 'Crank запросит подтверждение стандартным способом MCP Elicitation. MCP-клиент должен поддерживать эту возможность. Отдельный ключ подтверждения не используется: решение пользователя возвращается по текущему MCP-подключению.',
+    'wizard.approval.elicitation_message': 'Сообщение для MCP-клиента',
+    'wizard.approval.elicitation_message_placeholder': 'Подтвердите выполнение операции.',
+    'wizard.approval.elicitation_message_hint': 'Короткое сообщение для MCP-клиента. Внешний вид окна подтверждения определяет сам клиент.',
+    'wizard.approval.ttl': 'Сколько ждать подтверждение',
+    'wizard.approval.show_payload': 'Передавать параметры вызова в подтверждение',
+    'wizard.approval.payload_title': 'Параметры подтверждения',
+    'wizard.approval.payload_body': 'Если включено, Crank передаст параметры вызова вместе с запросом подтверждения. Так внешний интерфейс или MCP-клиент сможет показать пользователю, какое действие он подтверждает. Если параметры содержат чувствительные данные, выключите эту опцию.',
     'wizard.step5.security_level_title': 'Защита операции',
     'wizard.step5.community_security_note': '',
     'wizard.step5.live_title': 'Проверка и публикация',

apps/ui/js/logs.js

@@ -11,9 +11,14 @@ document.addEventListener('DOMContentLoaded', function () {
     workspaceId: null,
     loading: false,
     loadError: '',
+    approvals: [],
+    approvalsLoading: false,
+    approvalsError: '',
   };
 
   var logList = document.getElementById('log-list');
+  var approvalList = document.getElementById('approval-list');
+  var approvalRefreshBtn = document.getElementById('approval-refresh-btn');
   var logSearch = document.getElementById('log-search');
   var refreshBtn = document.getElementById('refresh-btn');
   var timeRangeSel = document.getElementById('time-range');
@@ -54,6 +59,19 @@ document.addEventListener('DOMContentLoaded', function () {
     return date.toISOString().slice(11, 23);
   }
 
+  function formatDateTime(timestamp) {
+    if (!timestamp) {
+      return '';
+    }
+    var date = new Date(timestamp);
+    return date.toLocaleString(window.CrankLocale || undefined, {
+      day: '2-digit',
+      month: 'short',
+      hour: '2-digit',
+      minute: '2-digit',
+    });
+  }
+
   function element(tag, className, text) {
     var node = document.createElement(tag);
     if (className) node.className = className;
@@ -111,6 +129,109 @@ document.addEventListener('DOMContentLoaded', function () {
     };
   }
 
+  function normalizeApproval(record) {
+    var approval = record.approval || record;
+    return {
+      id: approval.id,
+      agentId: approval.agent_id,
+      operationId: approval.operation_id,
+      operationVersion: approval.operation_version,
+      status: approval.status,
+      riskLevel: approval.risk_level,
+      requestPayload: approval.request_payload,
+      responsePayload: approval.response_payload,
+      createdAt: approval.created_at,
+      expiresAt: approval.expires_at,
+      decidedAt: approval.decided_at,
+      note: approval.decision_note,
+    };
+  }
+
+  function approvalStatusLabel(status) {
+    var key = 'approvals.status.' + status;
+    var translated = tKey(key);
+    return translated === key ? status : translated;
+  }
+
+  function renderApprovals() {
+    if (!approvalList) {
+      return;
+    }
+
+    approvalList.innerHTML = '';
+
+    if (state.approvalsLoading && state.approvals.length === 0) {
+      var loading = element('div', 'approval-empty', tKey('approvals.loading'));
+      approvalList.appendChild(loading);
+      return;
+    }
+
+    if (state.approvalsError) {
+      var error = element('div', 'approval-empty approval-empty-error', state.approvalsError);
+      approvalList.appendChild(error);
+      return;
+    }
+
+    if (!state.approvals.length) {
+      var empty = element('div', 'approval-empty', tKey('approvals.empty'));
+      approvalList.appendChild(empty);
+      return;
+    }
+
+    var fragment = document.createDocumentFragment();
+    state.approvals.forEach(function (item) {
+      var card = element('article', 'approval-item approval-' + item.status);
+
+      var header = element('div', 'approval-item-header');
+      var titleWrap = element('div', 'approval-item-title-wrap');
+      titleWrap.appendChild(element('div', 'approval-item-title', tKey('approvals.untitled') + ' ' + item.id));
+
+      var meta = element('div', 'approval-item-meta');
+      meta.textContent = [
+        tKey('approvals.operation') + ': ' + item.operationId + ' v' + item.operationVersion,
+        tKey('approvals.agent') + ': ' + item.agentId,
+      ].join(' · ');
+      titleWrap.appendChild(meta);
+      header.appendChild(titleWrap);
+
+      var badge = element('span', 'approval-status approval-status-' + item.status, approvalStatusLabel(item.status));
+      header.appendChild(badge);
+      card.appendChild(header);
+
+      var timing = element('div', 'approval-timing');
+      timing.textContent = item.status === 'pending'
+        ? tKey('approvals.expires_at') + ': ' + formatDateTime(item.expiresAt)
+        : tKey('approvals.updated_at') + ': ' + formatDateTime(item.decidedAt || item.createdAt);
+      card.appendChild(timing);
+
+      var payloadGrid = element('div', 'approval-payload-grid');
+      var requestBlock = element('div', 'approval-payload');
+      requestBlock.appendChild(element('div', 'approval-payload-label', tKey('approvals.request')));
+      var requestPre = element('pre', 'approval-payload-code');
+      requestPre.textContent = formatJson(item.requestPayload);
+      requestBlock.appendChild(requestPre);
+      payloadGrid.appendChild(requestBlock);
+
+      if (item.responsePayload !== null && item.responsePayload !== undefined) {
+        var responseBlock = element('div', 'approval-payload');
+        responseBlock.appendChild(element('div', 'approval-payload-label', tKey('approvals.response')));
+        var responsePre = element('pre', 'approval-payload-code');
+        responsePre.textContent = formatJson(item.responsePayload);
+        responseBlock.appendChild(responsePre);
+        payloadGrid.appendChild(responseBlock);
+      }
+      card.appendChild(payloadGrid);
+
+      if (item.note) {
+        card.appendChild(element('div', 'approval-note', item.note));
+      }
+
+      fragment.appendChild(card);
+    });
+
+    approvalList.appendChild(fragment);
+  }
+
   function renderEmpty(title, message) {
     logList.innerHTML = '';
     var empty = element('div', 'empty-state');
@@ -306,6 +427,39 @@ document.addEventListener('DOMContentLoaded', function () {
     }
   }
 
+  async function loadApprovals() {
+    if (!window.CrankApi) {
+      state.approvalsError = tKey('logs.error.api');
+      renderApprovals();
+      return;
+    }
+
+    state.workspaceId = currentWorkspaceId();
+    if (!state.workspaceId) {
+      state.approvalsError = tKey('logs.error.workspace');
+      renderApprovals();
+      return;
+    }
+
+    state.approvalsLoading = true;
+    state.approvalsError = '';
+    renderApprovals();
+
+    try {
+      var response = await window.CrankApi.listApprovals(state.workspaceId, { limit: 20 });
+      state.approvals = (response && response.items ? response.items : []).map(normalizeApproval);
+    } catch (error) {
+      state.approvalsError = error.message || tKey('approvals.error.load');
+    } finally {
+      state.approvalsLoading = false;
+      renderApprovals();
+    }
+  }
+
+  async function refreshOperationalData() {
+    await Promise.all([loadLogs(), loadApprovals()]);
+  }
+
   async function loadLogDetail(logId) {
     if (!window.CrankApi || !state.workspaceId || state.details[logId]) {
       return;
@@ -343,7 +497,7 @@ document.addEventListener('DOMContentLoaded', function () {
     if (!state.liveMode) {
       return;
     }
-    state.timer = setInterval(loadLogs, 4000);
+    state.timer = setInterval(refreshOperationalData, 4000);
   }
 
   function toggleLive() {
@@ -386,6 +540,16 @@ document.addEventListener('DOMContentLoaded', function () {
     });
   }
 
+  if (approvalRefreshBtn) {
+    approvalRefreshBtn.addEventListener('click', function () {
+      loadApprovals().then(function () {
+        if (!state.approvalsError && window.CrankUi) {
+          window.CrankUi.info(tKey('approvals.refresh.body'), tKey('approvals.refresh.title'));
+        }
+      });
+    });
+  }
+
   if (timeRangeSel) {
     timeRangeSel.value = state.period;
     timeRangeSel.addEventListener('change', function () {
@@ -405,15 +569,15 @@ document.addEventListener('DOMContentLoaded', function () {
   window.addEventListener('crank:workspacechange', function () {
     state.details = {};
     state.openId = null;
-    loadLogs();
+    refreshOperationalData();
   });
 
   setLiveState();
   startPolling();
 
   if (window.whenWorkspacesReady) {
-    window.whenWorkspacesReady().finally(loadLogs);
+    window.whenWorkspacesReady().finally(refreshOperationalData);
   } else {
-    loadLogs();
+    refreshOperationalData();
   }
 });

apps/ui/js/openapi-import.js

@@ -0,0 +1,556 @@
+(function() {
+  var state = {
+    workspaceId: null,
+    onImported: null,
+    jobId: null,
+    preview: null,
+    filterQuery: '',
+    filterMethod: '',
+  };
+
+  function qs(id) {
+    return document.getElementById(id);
+  }
+
+  function setStatus(message, isError) {
+    var node = qs('openapi-import-status');
+    if (!node) return;
+    node.textContent = message || '';
+    node.classList.toggle('error', !!isError);
+  }
+
+  function selectedKeys() {
+    return Array.from(document.querySelectorAll('[data-openapi-operation]:checked'))
+      .map(function(input) { return input.value; });
+  }
+
+  function operationRows() {
+    return Array.from(document.querySelectorAll('.openapi-import-operation'));
+  }
+
+  function visibleOperationRows() {
+    return operationRows().filter(function(row) { return !row.hidden; });
+  }
+
+  function updateSelection() {
+    var node = qs('openapi-import-selection');
+    var selectedCount = selectedKeys().length;
+    var totalCount = document.querySelectorAll('[data-openapi-operation]').length;
+    var visibleCount = visibleOperationRows().length;
+    if (node) node.textContent = 'Выбрано: ' + selectedCount + ' из ' + totalCount + ', показано: ' + visibleCount;
+    updateGroupSelectionState();
+  }
+
+  function updateGroupSelectionState() {
+    document.querySelectorAll('.openapi-import-group').forEach(function(groupNode) {
+      var rows = Array.from(groupNode.querySelectorAll('.openapi-import-operation'));
+      var visibleRows = rows.filter(function(row) { return !row.hidden; });
+      var visibleInputs = visibleRows
+        .map(function(row) { return row.querySelector('[data-openapi-operation]'); })
+        .filter(Boolean);
+      var selectedVisible = visibleInputs.filter(function(input) { return input.checked; }).length;
+      var selectedTotal = rows
+        .map(function(row) { return row.querySelector('[data-openapi-operation]'); })
+        .filter(function(input) { return input && input.checked; }).length;
+      var checkbox = groupNode.querySelector('[data-openapi-group]');
+      if (checkbox) {
+        checkbox.indeterminate = selectedVisible > 0 && selectedVisible < visibleInputs.length;
+        checkbox.checked = visibleInputs.length > 0 && selectedVisible === visibleInputs.length;
+      }
+      var counter = groupNode.querySelector('[data-openapi-group-count]');
+      if (counter) {
+        counter.textContent = 'выбрано ' + selectedTotal + ' из ' + rows.length + ', показано ' + visibleRows.length;
+      }
+    });
+  }
+
+  function applyFilters() {
+    var query = state.filterQuery.toLowerCase();
+    var method = state.filterMethod.toLowerCase();
+    document.querySelectorAll('.openapi-import-group').forEach(function(groupNode) {
+      var visibleInGroup = 0;
+      groupNode.querySelectorAll('.openapi-import-operation').forEach(function(row) {
+        var rowMethod = String(row.dataset.openapiMethod || '').toLowerCase();
+        var searchText = String(row.dataset.openapiSearch || '').toLowerCase();
+        var visible = (!method || rowMethod === method) && (!query || searchText.indexOf(query) >= 0);
+        row.hidden = !visible;
+        if (visible) visibleInGroup += 1;
+      });
+      groupNode.hidden = visibleInGroup === 0;
+    });
+    updateSelection();
+  }
+
+  function setVisibleSelection(checked) {
+    visibleOperationRows().forEach(function(row) {
+      var input = row.querySelector('[data-openapi-operation]');
+      if (input) input.checked = checked;
+    });
+    updateSelection();
+  }
+
+  function renderPreview(response) {
+    state.jobId = response.job_id;
+    state.preview = response.preview;
+    state.filterQuery = '';
+    state.filterMethod = '';
+    var preview = response.preview;
+    qs('openapi-import-preview-panel').hidden = false;
+    qs('openapi-import-result').hidden = true;
+    qs('openapi-import-result').innerHTML = '';
+    qs('openapi-import-source').textContent = [
+      preview.source.title || 'Imported API',
+      preview.source.format + (preview.source.version ? ' ' + preview.source.version : ''),
+      'методов: ' + preview.groups.reduce(function(sum, group) { return sum + group.operations.length; }, 0),
+    ].join(' · ');
+
+    var serverSelect = qs('openapi-import-server');
+    serverSelect.innerHTML = '';
+    var servers = preview.source.servers && preview.source.servers.length ? preview.source.servers : [''];
+    servers.forEach(function(server) {
+      var option = document.createElement('option');
+      option.value = server;
+      option.textContent = server || 'Указать позже';
+      serverSelect.appendChild(option);
+    });
+
+    var searchInput = qs('openapi-import-search');
+    var methodFilter = qs('openapi-import-method-filter');
+    if (searchInput) searchInput.value = '';
+    if (methodFilter) {
+      methodFilter.innerHTML = '<option value="">Все методы</option>';
+      Array.from(new Set(preview.groups.flatMap(function(group) {
+        return group.operations.map(function(operation) { return operation.method; });
+      }))).sort().forEach(function(method) {
+        var option = document.createElement('option');
+        option.value = method;
+        option.textContent = method;
+        methodFilter.appendChild(option);
+      });
+    }
+
+    var groupsNode = qs('openapi-import-groups');
+    groupsNode.innerHTML = '';
+    if (preview.findings && preview.findings.length) {
+      var documentFindings = document.createElement('div');
+      documentFindings.className = 'openapi-import-document-findings';
+      documentFindings.innerHTML = preview.findings.map(function(finding) {
+        return renderFinding(finding);
+      }).join('');
+      groupsNode.appendChild(documentFindings);
+    }
+    preview.groups.forEach(function(group) {
+      var groupNode = document.createElement('section');
+      groupNode.className = 'openapi-import-group';
+      var header = document.createElement('div');
+      header.className = 'openapi-import-group-header';
+      header.innerHTML = '<span>' + escapeHtml(group.title) + ' · ' + group.operations.length + '</span>'
+        + '<span class="openapi-import-group-count" data-openapi-group-count></span>'
+        + '<label class="openapi-import-group-toggle"><input type="checkbox" data-openapi-group checked> Выбрать группу</label>';
+      groupNode.appendChild(header);
+
+      group.operations.forEach(function(operation) {
+        var row = document.createElement('label');
+        row.className = 'openapi-import-operation';
+        row.dataset.openapiMethod = operation.method;
+        row.dataset.openapiSearch = [
+          group.title,
+          operation.key,
+          operation.suggested_name,
+          operation.suggested_display_name,
+          operation.path,
+          operation.method,
+        ].join(' ');
+        row.innerHTML = [
+          '<input type="checkbox" data-openapi-operation value="' + escapeHtml(operation.key) + '" checked>',
+          '<div><div class="openapi-import-operation-title">' + escapeHtml(operation.suggested_display_name) + '</div>',
+          '<div class="openapi-import-operation-meta"><code>' + escapeHtml(operation.suggested_name) + '</code> · ' + escapeHtml(operation.path) + ' · входов: ' + operation.input_fields + ' · выходов: ' + operation.output_fields + '</div></div>',
+          '<span class="openapi-import-method">' + escapeHtml(operation.method) + '</span>',
+        ].join('');
+        row.appendChild(renderOperationMappingPreview(operation));
+        if (operation.findings && operation.findings.length) {
+          var findings = document.createElement('div');
+          findings.className = 'openapi-import-findings';
+          findings.innerHTML = operation.findings.map(function(finding) {
+            return renderFinding(finding);
+          }).join('');
+          row.appendChild(findings);
+        }
+        groupNode.appendChild(row);
+      });
+      var groupCheckbox = groupNode.querySelector('[data-openapi-group]');
+      groupCheckbox.addEventListener('change', function() {
+        groupNode.querySelectorAll('.openapi-import-operation').forEach(function(row) {
+          if (row.hidden) return;
+          var input = row.querySelector('[data-openapi-operation]');
+          if (input) input.checked = groupCheckbox.checked;
+        });
+        updateSelection();
+      });
+      groupsNode.appendChild(groupNode);
+    });
+    groupsNode.querySelectorAll('[data-openapi-operation]').forEach(function(input) {
+      input.addEventListener('change', updateSelection);
+    });
+    applyFilters();
+  }
+
+  function renderOperationMappingPreview(operation) {
+    var details = document.createElement('div');
+    details.className = 'openapi-import-mapping-preview';
+
+    var request = summarizeRequestMapping(operation);
+    [
+      ['Path', request.path],
+      ['Query', request.query],
+      ['Header', request.headers],
+      ['Body', request.body],
+    ].forEach(function(entry) {
+      appendMappingGroup(details, entry[0], entry[1]);
+    });
+    appendMappingGroup(details, 'Ответ', summarizeResponseMapping(operation));
+    return details;
+  }
+
+  function summarizeRequestMapping(operation) {
+    var result = {
+      path: [],
+      query: [],
+      headers: [],
+      body: [],
+    };
+    var rules = operation
+      && operation.draft
+      && operation.draft.input_mapping
+      && Array.isArray(operation.draft.input_mapping.rules)
+      ? operation.draft.input_mapping.rules
+      : [];
+
+    rules.forEach(function(rule) {
+      var target = String(rule.target || '');
+      if (target.indexOf('$.request.path.') === 0) {
+        result.path.push(target.replace('$.request.path.', ''));
+      } else if (target.indexOf('$.request.query.') === 0) {
+        result.query.push(target.replace('$.request.query.', ''));
+      } else if (target.indexOf('$.request.headers.') === 0) {
+        result.headers.push(target.replace('$.request.headers.', ''));
+      } else if (target.indexOf('$.request.body.') === 0) {
+        result.body.push(target.replace('$.request.body.', ''));
+      } else if (target === '$.request.body') {
+        result.body.push('body');
+      }
+    });
+    return result;
+  }
+
+  function summarizeResponseMapping(operation) {
+    var rules = operation
+      && operation.draft
+      && operation.draft.output_mapping
+      && Array.isArray(operation.draft.output_mapping.rules)
+      ? operation.draft.output_mapping.rules
+      : [];
+
+    return rules.map(function(rule) {
+      var target = String(rule.target || '').replace('$.output.', '').replace('$.output', 'result');
+      var source = String(rule.source || '').replace('$.response.body.', '').replace('$.response.body', 'body');
+      return target + ' ← ' + source;
+    });
+  }
+
+  function appendMappingGroup(root, label, values) {
+    if (!values || !values.length) return;
+    var group = document.createElement('div');
+    group.className = 'openapi-import-mapping-group';
+
+    var title = document.createElement('span');
+    title.className = 'openapi-import-mapping-label';
+    title.textContent = label;
+    group.appendChild(title);
+
+    values.slice(0, 8).forEach(function(value) {
+      var chip = document.createElement('code');
+      chip.className = 'openapi-import-mapping-chip';
+      chip.textContent = value;
+      group.appendChild(chip);
+    });
+    if (values.length > 8) {
+      var more = document.createElement('span');
+      more.className = 'openapi-import-mapping-more';
+      more.textContent = '+' + (values.length - 8);
+      group.appendChild(more);
+    }
+    root.appendChild(group);
+  }
+
+  function escapeHtml(value) {
+    return String(value || '')
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;');
+  }
+
+  function renderFinding(finding) {
+    var severity = String(finding && finding.severity || 'warning').toLowerCase();
+    var label = severity === 'info' ? 'i' : severity === 'error' ? '×' : '!';
+    return '<span class="openapi-import-finding openapi-import-finding-' + escapeHtml(severity) + '">'
+      + '<strong>' + label + '</strong> '
+      + escapeHtml(finding.message)
+      + '</span>';
+  }
+
+  function previewOperationByName(name) {
+    if (!state.preview || !state.preview.groups) return null;
+    for (var groupIndex = 0; groupIndex < state.preview.groups.length; groupIndex += 1) {
+      var operations = state.preview.groups[groupIndex].operations || [];
+      for (var operationIndex = 0; operationIndex < operations.length; operationIndex += 1) {
+        if (operations[operationIndex].suggested_name === name) {
+          return operations[operationIndex];
+        }
+      }
+    }
+    return null;
+  }
+
+  function wizardHref(operationId) {
+    return ((window.CrankRoutes && window.CrankRoutes.wizard) || '/wizard/')
+      + '?mode=edit&operationId=' + encodeURIComponent(operationId);
+  }
+
+  function appendFindingNodes(root, findings) {
+    if (!findings || !findings.length) {
+      var empty = document.createElement('span');
+      empty.className = 'openapi-import-result-ok';
+      empty.textContent = 'Критичных замечаний нет';
+      root.appendChild(empty);
+      return;
+    }
+    findings.slice(0, 4).forEach(function(finding) {
+      var wrapper = document.createElement('div');
+      wrapper.innerHTML = renderFinding(finding);
+      root.appendChild(wrapper.firstElementChild);
+    });
+    if (findings.length > 4) {
+      var more = document.createElement('span');
+      more.className = 'openapi-import-result-more';
+      more.textContent = '+' + (findings.length - 4) + ' еще';
+      root.appendChild(more);
+    }
+  }
+
+  async function preview() {
+    if (!state.workspaceId) {
+      setStatus('Не выбран workspace.', true);
+      return;
+    }
+    var documentText = qs('openapi-import-document').value.trim();
+    if (!documentText) {
+      setStatus('Вставьте документ OpenAPI/Swagger или выберите файл.', true);
+      return;
+    }
+    setStatus('Разбираю документ...');
+    qs('openapi-import-preview').disabled = true;
+    try {
+      var response = await window.CrankApi.previewOpenApiImport(state.workspaceId, documentText);
+      renderPreview(response);
+      setStatus('Документ разобран. Выберите методы для импорта.');
+    } catch (error) {
+      setStatus(error.message || 'Не удалось разобрать документ.', true);
+    } finally {
+      qs('openapi-import-preview').disabled = false;
+    }
+  }
+
+  async function createDrafts() {
+    var keys = selectedKeys();
+    if (!keys.length) {
+      setStatus('Выберите хотя бы один метод.', true);
+      return;
+    }
+    if (!state.jobId) {
+      setStatus('Сначала разберите OpenAPI документ.', true);
+      return;
+    }
+    var serverUrl = (qs('openapi-import-server-custom').value || qs('openapi-import-server').value || '').trim();
+    if (!serverUrl) {
+      setStatus('Укажите base URL для создаваемых операций.', true);
+      return;
+    }
+    setStatus('Создаю черновики...');
+    qs('openapi-import-create').disabled = true;
+    try {
+      var response = await window.CrankApi.createOpenApiImport(state.workspaceId, state.jobId, {
+        selected_operation_keys: keys,
+        server_url: serverUrl,
+        conflict_mode: qs('openapi-import-conflict-mode').value || 'rename',
+      });
+      var message = 'Создано: ' + response.created.length;
+      if (response.skipped.length) message += ', пропущено: ' + response.skipped.length;
+      setStatus(message);
+      renderResult(response);
+      if (typeof state.onImported === 'function') {
+        await state.onImported();
+      }
+    } catch (error) {
+      setStatus(error.message || 'Не удалось создать черновики.', true);
+    } finally {
+      qs('openapi-import-create').disabled = false;
+    }
+  }
+
+  function renderResult(response) {
+    var node = qs('openapi-import-result');
+    if (!node) return;
+    node.replaceChildren();
+
+    var title = document.createElement('strong');
+    title.textContent = 'Результат импорта';
+    node.appendChild(title);
+
+    if (response.created && response.created.length) {
+      var firstHref = wizardHref(response.created[0].operation_id);
+      var primary = document.createElement('div');
+      primary.className = 'openapi-import-primary-result';
+      primary.innerHTML = '<a class="btn-primary" href="' + firstHref + '">Открыть первый черновик в мастере</a>';
+      node.appendChild(primary);
+
+      var table = document.createElement('div');
+      table.className = 'openapi-import-result-table';
+      table.setAttribute('role', 'table');
+      table.innerHTML = [
+        '<div class="openapi-import-result-row openapi-import-result-head" role="row">',
+        '<div role="columnheader">Черновик</div>',
+        '<div role="columnheader">Замечания</div>',
+        '<div role="columnheader">Действие</div>',
+        '</div>',
+      ].join('');
+
+      response.created.forEach(function(operation) {
+        var previewOperation = previewOperationByName(operation.name);
+        var row = document.createElement('div');
+        row.className = 'openapi-import-result-row';
+        row.setAttribute('role', 'row');
+
+        var nameCell = document.createElement('div');
+        nameCell.setAttribute('role', 'cell');
+        var name = document.createElement('div');
+        name.className = 'openapi-import-result-name';
+        name.textContent = operation.name;
+        var meta = document.createElement('div');
+        meta.className = 'openapi-import-result-meta';
+        meta.textContent = previewOperation
+          ? previewOperation.method + ' ' + previewOperation.path + ' · v' + operation.version
+          : 'v' + operation.version;
+        nameCell.appendChild(name);
+        nameCell.appendChild(meta);
+
+        var findingsCell = document.createElement('div');
+        findingsCell.className = 'openapi-import-result-findings';
+        findingsCell.setAttribute('role', 'cell');
+        appendFindingNodes(findingsCell, previewOperation ? previewOperation.findings : []);
+
+        var actionCell = document.createElement('div');
+        actionCell.setAttribute('role', 'cell');
+        var action = document.createElement('a');
+        action.className = 'btn-secondary openapi-import-result-action';
+        action.href = wizardHref(operation.operation_id);
+        action.textContent = previewOperation && previewOperation.findings && previewOperation.findings.length
+          ? 'Исправить в мастере'
+          : 'Открыть в мастере';
+        actionCell.appendChild(action);
+
+        row.appendChild(nameCell);
+        row.appendChild(findingsCell);
+        row.appendChild(actionCell);
+        table.appendChild(row);
+      });
+      node.appendChild(table);
+    }
+    if (response.skipped && response.skipped.length) {
+      var skipped = document.createElement('div');
+      skipped.className = 'openapi-import-result-skipped';
+      skipped.textContent = 'Пропущено: ' + response.skipped.map(function(item) {
+        return (item.name || item.operation_key) + ' — ' + item.reason;
+      }).join('; ');
+      node.appendChild(skipped);
+    }
+    if (response.findings && response.findings.length) {
+      var responseFindings = document.createElement('div');
+      responseFindings.className = 'openapi-import-result-findings';
+      response.findings.forEach(function(finding) {
+        var wrapper = document.createElement('div');
+        wrapper.innerHTML = renderFinding(finding);
+        responseFindings.appendChild(wrapper.firstElementChild);
+      });
+      node.appendChild(responseFindings);
+    }
+    node.hidden = false;
+  }
+
+  function reset() {
+    state.jobId = null;
+    state.preview = null;
+    state.filterQuery = '';
+    state.filterMethod = '';
+    qs('openapi-import-document').value = '';
+    qs('openapi-import-file').value = '';
+    qs('openapi-import-file-name').textContent = 'Файл не выбран';
+    qs('openapi-import-server-custom').value = '';
+    qs('openapi-import-conflict-mode').value = 'rename';
+    if (qs('openapi-import-search')) qs('openapi-import-search').value = '';
+    if (qs('openapi-import-method-filter')) qs('openapi-import-method-filter').innerHTML = '<option value="">Все методы</option>';
+    qs('openapi-import-preview-panel').hidden = true;
+    qs('openapi-import-groups').innerHTML = '';
+    qs('openapi-import-result').hidden = true;
+    qs('openapi-import-result').innerHTML = '';
+    setStatus('');
+    updateSelection();
+  }
+
+  function open(options) {
+    state.workspaceId = options.workspaceId;
+    state.onImported = options.onImported;
+    qs('openapi-import-modal').hidden = false;
+  }
+
+  function close() {
+    qs('openapi-import-modal').hidden = true;
+  }
+
+  document.addEventListener('DOMContentLoaded', function() {
+    if (!qs('openapi-import-modal')) return;
+    qs('openapi-import-preview').addEventListener('click', preview);
+    qs('openapi-import-create').addEventListener('click', createDrafts);
+    qs('openapi-import-reset').addEventListener('click', reset);
+    qs('openapi-import-search').addEventListener('input', function(event) {
+      state.filterQuery = event.target.value.trim();
+      applyFilters();
+    });
+    qs('openapi-import-method-filter').addEventListener('change', function(event) {
+      state.filterMethod = event.target.value;
+      applyFilters();
+    });
+    qs('openapi-import-select-visible').addEventListener('click', function() {
+      setVisibleSelection(true);
+    });
+    qs('openapi-import-clear-visible').addEventListener('click', function() {
+      setVisibleSelection(false);
+    });
+    qs('openapi-import-file').addEventListener('change', async function(event) {
+      var file = event.target.files && event.target.files[0];
+      if (!file) return;
+      qs('openapi-import-file-name').textContent = file.name;
+      qs('openapi-import-document').value = await file.text();
+    });
+    document.querySelectorAll('[data-openapi-close]').forEach(function(node) {
+      node.addEventListener('click', close);
+    });
+  });
+
+  window.CrankOpenApiImport = {
+    open: open,
+    close: close,
+    reset: reset,
+  };
+}());

apps/ui/js/wizard-live.js

@@ -13,17 +13,66 @@ function buildToolDescription() {
 }
 
 function buildWizardState() {
+  var snapshot = wizardCurrentVersion && wizardCurrentVersion.snapshot
+    ? wizardCurrentVersion.snapshot
+    : wizardCurrentVersion;
+  var existingState = snapshot && snapshot.wizard_state ? snapshot.wizard_state : {};
   return {
     input_sample: parseStructuredText(textValue('wizard-input-sample')),
     output_sample: parseStructuredText(textValue('wizard-output-sample')),
     test_input: parseStructuredText(textValue('wizard-test-input')),
+    import_findings: Array.isArray(existingState.import_findings)
+      ? existingState.import_findings.slice()
+      : [],
   };
 }
 
+function checkedValue(id) {
+  var element = document.getElementById(id);
+  return !!(element && element.checked);
+}
+
+function normalizeApprovalTtlSeconds(value) {
+  var ttl = Number(value || 300);
+  if (!Number.isFinite(ttl)) return 300;
+  return Math.max(1, Math.min(300, Math.round(ttl)));
+}
+
+function buildApprovalPolicy() {
+  if (!checkedValue('approval-required')) return null;
+
+  return {
+    required: true,
+    mode: textValue('approval-mode') || 'custom',
+    risk_level: 'normal',
+    ttl_seconds: normalizeApprovalTtlSeconds(textValue('approval-ttl-seconds')),
+    show_payload_preview: checkedValue('approval-show-payload-preview'),
+    payload_preview_mode: 'summary',
+    elicitation_message: textValue('approval-mode') === 'elicitation'
+      ? (textValue('approval-elicitation-message') || null)
+      : null,
+  };
+}
+
+function applyApprovalPolicyToExecutionConfig(config) {
+  var next = config || {};
+  var policy = buildApprovalPolicy();
+  if (policy) {
+    next.approval_policy = policy;
+  } else {
+    next.approval_policy = null;
+  }
+  return next;
+}
+
 function collectWizardPayload() {
   var name = textValue('tool-name');
   if (!name) throw new Error(tKey('wizard.error.tool_name'));
 
+  if (window.CrankWizardMapping && typeof window.CrankWizardMapping.sync === 'function') {
+    window.CrankWizardMapping.sync();
+  }
+
   var inputSchemaValue = parseStructuredText(textValue('tool-input-schema'));
   var outputSchemaValue = parseStructuredText(textValue('tool-output-schema'));
   var inputMappingValue = parseStructuredText(textValue('tool-input-mapping'));
@@ -39,7 +88,7 @@ function collectWizardPayload() {
     output_schema: convertJsonSchemaToCrankSchema(outputSchemaValue, []),
     input_mapping: buildMappingSet(inputMappingValue, 'input'),
     output_mapping: buildMappingSet(outputMappingValue, 'output'),
-    execution_config: parseExecutionConfig(textValue('tool-exec-config')),
+    execution_config: applyApprovalPolicyToExecutionConfig(parseExecutionConfig(textValue('tool-exec-config'))),
     tool_description: buildToolDescription(),
     wizard_state: buildWizardState(),
   };
@@ -69,6 +118,7 @@ async function loadOperationForEdit() {
   wizardCurrentVersion = draftVersion;
   prefillWizardFromEdit(detail, draftVersion);
   renderAgentFacingPreview();
+  renderImportQualityFindings(draftVersion);
 }
 
 function setEditModePresentation() {
@@ -111,6 +161,10 @@ function bindWizardLiveActions() {
 
   var yamlInput = document.getElementById('wizard-import-yaml-file');
   if (yamlInput) yamlInput.addEventListener('change', handleImportYamlFileSelection);
+  if (window.CrankWizardMapping && typeof window.CrankWizardMapping.initialize === 'function') {
+    window.CrankWizardMapping.initialize();
+  }
+  bindApprovalPolicyControls();
   bindAgentFacingPreview();
 }
 
@@ -132,6 +186,52 @@ function bindLiveAction(id, busyLabel, handler) {
   });
 }
 
+function setApprovalPolicyEditor(policy) {
+  var enabled = !!(policy && policy.required);
+  var required = document.getElementById('approval-required');
+  if (required) required.checked = enabled;
+  setValue('approval-mode', policy && policy.mode ? policy.mode : 'custom');
+  setValue('approval-elicitation-message', policy && policy.elicitation_message ? policy.elicitation_message : '');
+  setValue('approval-ttl-seconds', policy && policy.ttl_seconds ? String(policy.ttl_seconds) : '300');
+  var showPayload = document.getElementById('approval-show-payload-preview');
+  if (showPayload) {
+    showPayload.checked = !policy || policy.show_payload_preview !== false;
+  }
+  updateApprovalPolicyUi();
+}
+
+function updateApprovalPolicyUi() {
+  var enabled = checkedValue('approval-required');
+  var toggle = document.getElementById('approval-required-toggle');
+  var fields = document.getElementById('approval-config-fields');
+  var mode = textValue('approval-mode') || 'custom';
+  var customInfo = document.getElementById('approval-custom-info');
+  var elicitationInfo = document.getElementById('approval-elicitation-info');
+  var elicitationMessage = document.getElementById('approval-elicitation-message-group');
+  if (toggle) toggle.classList.toggle('on', enabled);
+  if (fields) fields.hidden = !enabled;
+  if (customInfo) customInfo.hidden = mode !== 'custom';
+  if (elicitationInfo) elicitationInfo.hidden = mode !== 'elicitation';
+  if (elicitationMessage) elicitationMessage.hidden = mode !== 'elicitation';
+}
+
+function bindApprovalPolicyControls() {
+  [
+    'approval-required',
+    'approval-mode',
+    'approval-elicitation-message',
+    'approval-ttl-seconds',
+    'approval-show-payload-preview',
+  ].forEach(function(id) {
+    var element = document.getElementById(id);
+    if (!element || element.dataset.approvalBound === 'true') return;
+    element.dataset.approvalBound = 'true';
+    element.addEventListener('input', updateApprovalPolicyUi);
+    element.addEventListener('change', updateApprovalPolicyUi);
+  });
+  updateApprovalPolicyUi();
+}
+
 async function runWizardLiveAction(button, busyLabel, handler) {
   if (!button || button.dataset.busy === 'true') {
     return;
@@ -421,6 +521,50 @@ function severityLabel(severity) {
   return tKey('wizard.quality.severity_info');
 }
 
+function qualityTargetForFinding(finding) {
+  var code = String(finding && finding.code || '');
+  var path = String(finding && finding.field_path || '');
+
+  if (code.indexOf('tool_name') >= 0 || code.indexOf('weak_tool_name') >= 0) {
+    return { step: 4, selector: '#tool-name', label: 'Перейти к имени инструмента' };
+  }
+  if (code.indexOf('description') >= 0 || path.indexOf('tool_description') >= 0) {
+    return { step: 4, selector: '#tool-description', label: 'Перейти к описанию' };
+  }
+  if (code.indexOf('input') >= 0 || code.indexOf('parameter') >= 0 || path.indexOf('input_schema') >= 0) {
+    return { step: 4, selector: '#tool-input-schema', label: 'Перейти к входной схеме' };
+  }
+  if (code.indexOf('output') >= 0 || code.indexOf('response_schema') >= 0 || path.indexOf('output_schema') >= 0) {
+    return { step: 4, selector: '#tool-output-schema', label: 'Перейти к схеме ответа' };
+  }
+  if (code.indexOf('response_projection') >= 0 || code.indexOf('mapping') >= 0 || path.indexOf('output_mapping') >= 0) {
+    return { step: 5, selector: '#tool-output-mapping', label: 'Перейти к маппингу ответа' };
+  }
+  return null;
+}
+
+function focusWizardQualityTarget(target) {
+  if (!target || !window.CrankWizardShell) return;
+  var load = typeof window.CrankWizardShell.loadWizardPanels === 'function'
+    ? window.CrankWizardShell.loadWizardPanels([target.step])
+    : Promise.resolve();
+  load.then(function() {
+    if (typeof window.CrankWizardShell.doGoToStep === 'function') {
+      window.CrankWizardShell.doGoToStep(target.step);
+    }
+    window.setTimeout(function() {
+      var element = document.querySelector(target.selector);
+      if (!element) return;
+      element.scrollIntoView({ behavior: 'smooth', block: 'center' });
+      if (typeof element.focus === 'function') element.focus();
+      element.classList.add('quality-focus-target');
+      window.setTimeout(function() {
+        element.classList.remove('quality-focus-target');
+      }, 1600);
+    }, 80);
+  });
+}
+
 function renderQualityFindings(report) {
   var empty = document.getElementById('wizard-quality-empty');
   var list = document.getElementById('wizard-quality-findings');
@@ -454,6 +598,19 @@ function renderQualityFindings(report) {
       item.appendChild(action);
     }
 
+    var target = qualityTargetForFinding(finding);
+    if (target) {
+      var button = document.createElement('button');
+      button.type = 'button';
+      button.className = 'btn-ghost-sm quality-finding-jump';
+      button.textContent = target.label;
+      button.addEventListener('click', function(event) {
+        event.preventDefault();
+        focusWizardQualityTarget(target);
+      });
+      item.appendChild(button);
+    }
+
     if (finding.field_path) {
       var path = document.createElement('div');
       path.className = 'quality-finding-path';
@@ -465,6 +622,26 @@ function renderQualityFindings(report) {
   });
 }
 
+function renderImportQualityFindings(versionDocument) {
+  var snapshot = versionDocument && versionDocument.snapshot
+    ? versionDocument.snapshot
+    : versionDocument;
+  var state = snapshot && snapshot.wizard_state ? snapshot.wizard_state : {};
+  var findings = Array.isArray(state.import_findings) ? state.import_findings : [];
+  if (!findings.length) return;
+
+  renderQualityFindings({
+    blocking: findings.some(function(finding) { return finding.severity === 'error'; }),
+    findings: findings,
+  });
+
+  var empty = document.getElementById('wizard-quality-empty');
+  if (empty) {
+    empty.textContent = 'Рекомендации из OpenAPI import. Запустите проверку качества, чтобы пересчитать их по текущему черновику.';
+    empty.hidden = false;
+  }
+}
+
 async function analyzeWizardQuality() {
   if (!wizardWorkspaceId) {
     throw new Error(tKey('wizard.error.no_workspace'));
@@ -574,6 +751,9 @@ async function generateDraftFromWizard() {
   setValue('tool-output-schema', JSON.stringify(crankSchemaToJsonSchema(generated.output_schema), null, 2));
   setValue('tool-input-mapping', mappingSetToEditorValue(generated.input_mapping, 'input', wizardProtocol));
   setValue('tool-output-mapping', mappingSetToEditorValue(generated.output_mapping, 'output', wizardProtocol));
+  if (window.CrankWizardMapping && typeof window.CrankWizardMapping.renderFromEditors === 'function') {
+    window.CrankWizardMapping.renderFromEditors();
+  }
   renderAgentFacingPreview();
   showWizardLiveStatus(tKey('wizard.sample.generated'), tKey('wizard.sample.generated_body'));
 }
@@ -613,4 +793,5 @@ function copyTestResponseToOutputSample() {
   bindWizardLiveActions: bindWizardLiveActions,
   updateWizardProtocolVisibility: updateWizardProtocolVisibility,
   renderAgentFacingPreview: renderAgentFacingPreview,
+  setApprovalPolicyEditor: setApprovalPolicyEditor,
 };

apps/ui/js/wizard-mapping.js

@@ -0,0 +1,752 @@
+(function() {
+  var REQUEST_TARGETS = ['path', 'query', 'headers', 'body'];
+  var SCALAR_TYPES = ['string', 'number', 'integer', 'boolean', 'null'];
+  var suspendSync = false;
+
+  function field(id) {
+    return document.getElementById(id);
+  }
+
+  function readText(id) {
+    var element = field(id);
+    return element ? element.value.trim() : '';
+  }
+
+  function writeText(id, value) {
+    var element = field(id);
+    if (element) element.value = value || '';
+  }
+
+  function parseText(id) {
+    if (typeof parseStructuredText === 'function') {
+      return parseStructuredText(readText(id));
+    }
+    return JSON.parse(readText(id));
+  }
+
+  function dumpYaml(object) {
+    return window.jsyaml
+      ? window.jsyaml.dump(object, { lineWidth: -1, noRefs: true })
+      : JSON.stringify(object, null, 2);
+  }
+
+  function safeJson(id) {
+    try {
+      return parseText(id);
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  function scalarType(value) {
+    if (value === null) return 'null';
+    if (Array.isArray(value)) return 'array';
+    var typeName = typeof value;
+    if (typeName === 'number') return Number.isInteger(value) ? 'integer' : 'number';
+    if (typeName === 'boolean') return 'boolean';
+    if (typeName === 'object') return 'object';
+    return 'string';
+  }
+
+  function inferJsonSchema(value) {
+    var typeName = scalarType(value);
+    if (typeName === 'object') {
+      var properties = {};
+      var required = [];
+      Object.keys(value || {}).forEach(function(name) {
+        properties[name] = inferJsonSchema(value[name]);
+        if (value[name] !== null && value[name] !== undefined) required.push(name);
+      });
+      var schema = {
+        type: 'object',
+        properties: properties,
+        additionalProperties: false,
+      };
+      if (required.length) schema.required = required;
+      return schema;
+    }
+    if (typeName === 'array') {
+      return {
+        type: 'array',
+        items: value.length ? inferJsonSchema(value[0]) : { type: 'string' },
+      };
+    }
+    return { type: typeName };
+  }
+
+  function collectSchemaFields(schema, prefix) {
+    var result = [];
+    var node = schema || {};
+    if (node.type === 'object' && node.properties) {
+      Object.keys(node.properties).forEach(function(name) {
+        var child = node.properties[name] || {};
+        var path = prefix ? prefix + '.' + name : name;
+        if (child.type === 'object' && child.properties) {
+          result = result.concat(collectSchemaFields(child, path));
+        } else {
+          result.push({
+            name: path,
+            required: Array.isArray(node.required) && node.required.indexOf(name) >= 0,
+          });
+        }
+      });
+    }
+    return result;
+  }
+
+  function requiredSchemaFields(schema) {
+    return collectSchemaFields(schema, '').filter(function(item) {
+      return item.required;
+    }).map(function(item) {
+      return item.name;
+    });
+  }
+
+  function collectJsonLeaves(value, prefix) {
+    var result = [];
+    if (Array.isArray(value)) {
+      if (!value.length) {
+        if (prefix) result.push({ name: prefix, required: true, array: true });
+        return result;
+      }
+      var samplePath = prefix ? prefix + '[0]' : '[0]';
+      return collectJsonLeaves(value[0], samplePath).map(function(item) {
+        item.array = true;
+        return item;
+      });
+    }
+    if (value && typeof value === 'object') {
+      Object.keys(value).forEach(function(name) {
+        var path = prefix ? prefix + '.' + name : name;
+        var child = value[name];
+        if (child && typeof child === 'object') {
+          result = result.concat(collectJsonLeaves(child, path));
+        } else {
+          result.push({ name: path, required: child !== null && child !== undefined });
+        }
+      });
+      return result;
+    }
+    if (prefix) result.push({ name: prefix, required: true });
+    return result;
+  }
+
+  function pathParams() {
+    var path = readText('endpoint-path') || '';
+    var params = [];
+    path.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, function(_match, name) {
+      params.push(name);
+      return _match;
+    });
+    path.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, function(_match, name) {
+      params.push(name);
+      return _match;
+    });
+    return Array.from(new Set(params));
+  }
+
+  function currentMethod() {
+    var active = document.querySelector('.method-card.active');
+    return active ? active.dataset.method || 'GET' : 'GET';
+  }
+
+  function defaultTargetKind() {
+    var method = currentMethod().toUpperCase();
+    return method === 'GET' || method === 'DELETE' ? 'query' : 'body';
+  }
+
+  function splitRequestTarget(target) {
+    var value = String(target || '').replace(/^\$\.request\./, '').replace(/^request\./, '');
+    var parts = value.split('.');
+    var kind = parts.shift() || defaultTargetKind();
+    if (REQUEST_TARGETS.indexOf(kind) < 0) kind = defaultTargetKind();
+    return { kind: kind, name: parts.join('.') };
+  }
+
+  function sourceToField(source) {
+    return String(source || '')
+      .replace(/^\$\.mcp\.?/, '')
+      .replace(/^\$\.input\.?/, '');
+  }
+
+  function responseSourceToPath(source) {
+    return String(source || '')
+      .replace(/^\$\.response\.body\.?/, '')
+      .replace(/^\$\.response\.data\.?/, '');
+  }
+
+  function outputTargetToField(target) {
+    return String(target || '').replace(/^\$\.output\.?/, '');
+  }
+
+  function mappingEntrySource(entry) {
+    return entry && typeof entry === 'object' && !Array.isArray(entry)
+      ? entry.source
+      : entry;
+  }
+
+  function mappingEntryDefault(entry) {
+    return entry && typeof entry === 'object' && !Array.isArray(entry) && Object.prototype.hasOwnProperty.call(entry, 'default_value')
+      ? entry.default_value
+      : undefined;
+  }
+
+  function mappingEntryTransform(entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry) || entry.transform === undefined || entry.transform === null) {
+      return '';
+    }
+    var value = typeof entry.transform === 'object' ? entry.transform.kind : entry.transform;
+    value = String(value || '').trim();
+    return transformKinds().indexOf(value) >= 0 ? value : '';
+  }
+
+  function defaultValueToText(value) {
+    if (value === undefined) return '';
+    if (typeof value === 'string') return value;
+    return JSON.stringify(value);
+  }
+
+  function parseDefaultValue(text) {
+    var value = String(text || '').trim();
+    if (!value) return undefined;
+    if (/^(true|false|null)$/i.test(value) || /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(value) || /^[\[{]/.test(value)) {
+      try {
+        return JSON.parse(value);
+      } catch (_error) {
+        return value;
+      }
+    }
+    return value;
+  }
+
+  function transformKinds() {
+    return [
+      'to_string',
+      'to_number',
+      'to_boolean',
+      'join',
+      'split',
+      'wrap_array',
+      'unwrap_singleton',
+    ];
+  }
+
+  function requestRowsFromEditor() {
+    var parsed = safeJson('tool-input-mapping') || {};
+    return Object.keys(parsed).map(function(target) {
+      var entry = parsed[target];
+      var source = mappingEntrySource(entry);
+      var split = splitRequestTarget(target);
+      return {
+        input: sourceToField(source) || split.name,
+        target: split.kind,
+        apiName: split.name || sourceToField(source),
+        defaultValue: defaultValueToText(mappingEntryDefault(entry)),
+        transform: mappingEntryTransform(entry),
+      };
+    });
+  }
+
+  function responseRowsFromEditor() {
+    var parsed = safeJson('tool-output-mapping') || {};
+    return Object.keys(parsed).map(function(outputField) {
+      var source = mappingEntrySource(parsed[outputField]);
+      return {
+        output: outputField,
+        responsePath: responseSourceToPath(source) || outputField,
+      };
+    });
+  }
+
+  function suggestedRequestRows() {
+    var rows = [];
+    pathParams().forEach(function(name) {
+      rows.push({ input: name, target: 'path', apiName: name });
+    });
+
+    var sample = safeJson('wizard-input-sample');
+    var fields = [];
+    if (sample && typeof sample === 'object') {
+      fields = collectJsonLeaves(sample, '');
+    }
+    if (!fields.length) {
+      fields = collectSchemaFields(safeJson('tool-input-schema'), '');
+    }
+
+    var pathSet = new Set(rows.map(function(row) { return row.input; }));
+    fields.forEach(function(item) {
+      if (pathSet.has(item.name)) return;
+      rows.push({
+        input: item.name,
+        target: defaultTargetKind(),
+        apiName: item.name,
+      });
+    });
+    return rows;
+  }
+
+  function suggestedResponseRows() {
+    var sample = safeJson('wizard-output-sample');
+    var fields = sample && typeof sample === 'object'
+      ? collectJsonLeaves(sample, '')
+      : collectSchemaFields(safeJson('tool-output-schema'), '');
+    return fields.map(function(item) {
+      return {
+        output: outputNameFromPath(item.name),
+        responsePath: item.name,
+      };
+    });
+  }
+
+  function outputNameFromPath(path) {
+    return String(path || 'value')
+      .replace(/^\[0\]\.?/, 'item_')
+      .replace(/\[([0-9]+)\]/g, '_$1')
+      .replace(/[^A-Za-z0-9_]+/g, '_')
+      .replace(/^_+|_+$/g, '')
+      || 'value';
+  }
+
+  function joinJsonPath(root, relativePath) {
+    var path = String(relativePath || '').trim();
+    if (!path) return root;
+    return path.charAt(0) === '[' ? root + path : root + '.' + path;
+  }
+
+  function makeOption(value, label, selected) {
+    var option = document.createElement('option');
+    option.value = value;
+    option.textContent = label;
+    option.selected = selected;
+    return option;
+  }
+
+  function makeInput(value, className, placeholder) {
+    var input = document.createElement('input');
+    input.className = className || 'form-input input-mono';
+    input.value = value === undefined || value === null ? '' : String(value);
+    input.placeholder = placeholder || '';
+    input.autocomplete = 'off';
+    input.spellcheck = false;
+    input.addEventListener('input', syncVisualMappingsToYaml);
+    input.addEventListener('change', syncVisualMappingsToYaml);
+    return input;
+  }
+
+  function makeRemoveButton(row) {
+    var button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'row-btn row-btn-delete mapping-row-remove';
+    button.title = 'Удалить строку';
+    button.textContent = '×';
+    button.addEventListener('click', function() {
+      row.remove();
+      syncVisualMappingsToYaml();
+    });
+    return button;
+  }
+
+  function wrapMappingControl(labelText, control) {
+    var wrapper = document.createElement('label');
+    wrapper.className = 'mapping-field';
+    var label = document.createElement('span');
+    label.className = 'mapping-field-label';
+    label.textContent = labelText;
+    wrapper.appendChild(label);
+    wrapper.appendChild(control);
+    return wrapper;
+  }
+
+  function makeMappingArrow() {
+    var arrow = document.createElement('span');
+    arrow.className = 'mapping-arrow';
+    arrow.setAttribute('aria-hidden', 'true');
+    arrow.textContent = '→';
+    return arrow;
+  }
+
+  function renderRequestRows(rows) {
+    var root = field('wizard-request-mapping-rows');
+    if (!root) return;
+    root.replaceChildren();
+    if (!rows.length) rows = suggestedRequestRows();
+    rows.forEach(function(row) {
+      root.appendChild(createRequestRow(row));
+    });
+    if (!suspendSync) syncVisualMappingsToYaml();
+  }
+
+  function createRequestRow(row) {
+    var item = document.createElement('div');
+    item.className = 'mapping-row request-mapping-row';
+    item.dataset.mappingRow = 'request';
+
+    var input = makeInput(row.input, 'form-input input-mono mapping-source', 'base');
+    input.dataset.role = 'input';
+    input.title = 'Поле, которое MCP клиент передает инструменту';
+    item.appendChild(wrapMappingControl('Из инструмента', input));
+
+    item.appendChild(makeMappingArrow());
+
+    var select = document.createElement('select');
+    select.className = 'form-select mapping-target';
+    select.dataset.role = 'target';
+    [
+      ['path', 'Path'],
+      ['query', 'Query'],
+      ['headers', 'Header'],
+      ['body', 'Body'],
+    ].forEach(function(entry) {
+      select.appendChild(makeOption(entry[0], entry[1], entry[0] === row.target));
+    });
+    select.addEventListener('change', syncVisualMappingsToYaml);
+    item.appendChild(wrapMappingControl('Куда в API', select));
+
+    var apiName = makeInput(row.apiName || row.input, 'form-input input-mono mapping-api-name', 'base');
+    apiName.dataset.role = 'apiName';
+    apiName.title = 'Имя path, query, header или body-поля в API-запросе';
+    item.appendChild(wrapMappingControl('Имя в API', apiName));
+
+    var defaultValue = makeInput(row.defaultValue, 'form-input input-mono mapping-default-value', 'если не передано');
+    defaultValue.dataset.role = 'defaultValue';
+    defaultValue.title = 'Необязательно. Это значение уйдет в API, если агент не передал поле инструмента.';
+    item.appendChild(wrapMappingControl('Если пусто', defaultValue));
+
+    var transform = document.createElement('select');
+    transform.className = 'form-select mapping-transform';
+    transform.dataset.role = 'transform';
+    transform.appendChild(makeOption('', 'Без преобразования', !row.transform));
+    transformKinds().forEach(function(kind) {
+      transform.appendChild(makeOption(kind, kind, kind === row.transform));
+    });
+    transform.title = 'Простое преобразование перед отправкой в API';
+    transform.addEventListener('change', syncVisualMappingsToYaml);
+    item.appendChild(wrapMappingControl('Преобразование', transform));
+
+    item.appendChild(makeRemoveButton(item));
+    return item;
+  }
+
+  function renderResponseRows(rows) {
+    var root = field('wizard-response-mapping-rows');
+    if (!root) return;
+    root.replaceChildren();
+    if (!rows.length) rows = suggestedResponseRows();
+    rows.forEach(function(row) {
+      root.appendChild(createResponseRow(row));
+    });
+    if (!suspendSync) syncVisualMappingsToYaml();
+  }
+
+  function createResponseRow(row) {
+    var item = document.createElement('div');
+    item.className = 'mapping-row response-mapping-row';
+    item.dataset.mappingRow = 'response';
+
+    var responsePath = makeInput(row.responsePath, 'form-input input-mono mapping-response-path', 'rates.EUR');
+    responsePath.dataset.role = 'responsePath';
+    responsePath.title = 'Поле из ответа API';
+    item.appendChild(wrapMappingControl('Из ответа API', responsePath));
+
+    item.appendChild(makeMappingArrow());
+
+    var output = makeInput(row.output, 'form-input input-mono mapping-output-field', 'rate');
+    output.dataset.role = 'output';
+    output.title = 'Поле результата, которое получит MCP клиент';
+    item.appendChild(wrapMappingControl('В результат инструмента', output));
+    item.appendChild(makeRemoveButton(item));
+    return item;
+  }
+
+  function valueIn(row, role) {
+    var input = row.querySelector('[data-role="' + role + '"]');
+    return input ? input.value.trim() : '';
+  }
+
+  function syncVisualMappingsToYaml() {
+    var requestRows = document.querySelectorAll('[data-mapping-row="request"]');
+    if (requestRows.length) {
+      var requestMapping = {};
+      requestRows.forEach(function(row) {
+        var input = valueIn(row, 'input');
+        var target = valueIn(row, 'target');
+        var apiName = valueIn(row, 'apiName') || input;
+        var defaultText = valueIn(row, 'defaultValue');
+        var transform = valueIn(row, 'transform');
+        if (!input || !target || !apiName) return;
+        if (defaultText || transform) {
+          var entry = { source: '$.input.' + input };
+          if (defaultText) entry.default_value = parseDefaultValue(defaultText);
+          if (transform) entry.transform = transform;
+          requestMapping[target + '.' + apiName] = entry;
+          return;
+        }
+        requestMapping[target + '.' + apiName] = '$.input.' + input;
+      });
+      writeText('tool-input-mapping', dumpYaml(requestMapping));
+    }
+
+    var responseRows = document.querySelectorAll('[data-mapping-row="response"]');
+    if (responseRows.length) {
+      var responseMapping = {};
+      responseRows.forEach(function(row) {
+        var responsePath = valueIn(row, 'responsePath');
+        var output = valueIn(row, 'output') || outputNameFromPath(responsePath);
+        if (!responsePath || !output) return;
+        responseMapping[output] = joinJsonPath('$.response.body', responsePath);
+      });
+      writeText('tool-output-mapping', dumpYaml(responseMapping));
+    }
+    renderMappingWarnings();
+  }
+
+  function currentRequestMappedInputs() {
+    return Array.from(document.querySelectorAll('[data-mapping-row="request"]')).map(function(row) {
+      return valueIn(row, 'input');
+    }).filter(Boolean);
+  }
+
+  function currentResponseMappedOutputs() {
+    return Array.from(document.querySelectorAll('[data-mapping-row="response"]')).map(function(row) {
+      return valueIn(row, 'output');
+    }).filter(Boolean);
+  }
+
+  function jsonParseWarning(id, label) {
+    var raw = readText(id);
+    if (!raw) return null;
+    try {
+      parseText(id);
+      return null;
+    } catch (error) {
+      return label + ': JSON не разобран. ' + error.message;
+    }
+  }
+
+  function buildMappingWarnings() {
+    var warnings = [];
+    var inputJsonWarning = jsonParseWarning('wizard-input-sample', 'Пример входных данных');
+    var outputJsonWarning = jsonParseWarning('wizard-output-sample', 'Пример ответа');
+    if (inputJsonWarning) warnings.push(inputJsonWarning);
+    if (outputJsonWarning) warnings.push(outputJsonWarning);
+
+    var required = requiredSchemaFields(safeJson('tool-input-schema'));
+    var mapped = new Set(currentRequestMappedInputs());
+    var missing = required.filter(function(name) { return !mapped.has(name); });
+    if (missing.length) {
+      warnings.push('Обязательные поля входной схемы не отправляются в API: ' + missing.join(', ') + '.');
+    }
+
+    var outputRows = currentResponseMappedOutputs();
+    if (!outputRows.length) {
+      warnings.push('Ответ инструмента пустой. Выберите хотя бы одно поле из ответа API.');
+    }
+    if (outputRows.length > 12) {
+      warnings.push('В ответ инструмента выбрано много полей: ' + outputRows.length + '. Лучше вернуть только данные, нужные агенту.');
+    }
+    var hasArrayIndex = Array.from(document.querySelectorAll('[data-mapping-row="response"]')).some(function(row) {
+      return /\[[0-9]+\]/.test(valueIn(row, 'responsePath'));
+    });
+    if (hasArrayIndex) {
+      warnings.push('В ответе выбрано поле из одного элемента массива. Если агенту нужен весь список, верните массив целиком через расширенный YAML-маппинг.');
+    }
+    return warnings;
+  }
+
+  function renderMappingWarnings() {
+    var root = field('wizard-mapping-warnings');
+    if (!root) return;
+    var warnings = buildMappingWarnings();
+    root.replaceChildren();
+    root.hidden = warnings.length === 0;
+    warnings.forEach(function(message) {
+      var item = document.createElement('div');
+      item.className = 'mapping-warning';
+      var title = document.createElement('strong');
+      title.textContent = 'Проверьте маппинг. ';
+      item.appendChild(title);
+      item.appendChild(document.createTextNode(message));
+      root.appendChild(item);
+    });
+  }
+
+  function renderResponseTree() {
+    var root = field('wizard-response-json-tree');
+    if (!root) return;
+    root.replaceChildren();
+    var sample = safeJson('wizard-output-sample');
+    var leaves = sample && typeof sample === 'object' ? collectJsonLeaves(sample, '') : [];
+    if (!leaves.length) {
+      var empty = document.createElement('div');
+      empty.className = 'form-hint';
+      empty.textContent = 'Добавьте пример ответа JSON, чтобы выбрать поля кликом.';
+      root.appendChild(empty);
+      return;
+    }
+    leaves.forEach(function(leaf) {
+      var button = document.createElement('button');
+      button.type = 'button';
+      button.className = 'json-tree-node';
+      button.textContent = leaf.name;
+      button.addEventListener('click', function() {
+        var output = outputNameFromPath(leaf.name);
+        field('wizard-response-mapping-rows').appendChild(createResponseRow({
+          responsePath: leaf.name,
+          output: output,
+        }));
+        syncVisualMappingsToYaml();
+      });
+      root.appendChild(button);
+    });
+  }
+
+  function formatSamplesAndInferSchemas() {
+    var input = parseText('wizard-input-sample');
+    var output = parseText('wizard-output-sample');
+    writeText('wizard-input-sample', JSON.stringify(input, null, 2));
+    writeText('wizard-test-input', JSON.stringify(input, null, 2));
+    writeText('wizard-output-sample', JSON.stringify(output, null, 2));
+    writeText('tool-input-schema', JSON.stringify(inferJsonSchema(input), null, 2));
+    writeText('tool-output-schema', JSON.stringify(inferJsonSchema(output), null, 2));
+    renderRequestRows(suggestedRequestRows());
+    renderResponseRows(suggestedResponseRows());
+    renderResponseTree();
+    if (window.CrankWizardLive && typeof window.CrankWizardLive.renderAgentFacingPreview === 'function') {
+      window.CrankWizardLive.renderAgentFacingPreview();
+    }
+  }
+
+  function loadJsonFile(inputId, targetTextareaId, afterLoad) {
+    var input = field(inputId);
+    if (!input) return;
+    var file = input.files && input.files[0];
+    if (!file) return;
+    var reader = new FileReader();
+    reader.onload = function(event) {
+      try {
+        var parsed = JSON.parse(event.target.result || '{}');
+        writeText(targetTextareaId, JSON.stringify(parsed, null, 2));
+        if (afterLoad) afterLoad();
+      } catch (error) {
+        if (window.CrankUi) {
+          window.CrankUi.error(error.message, 'JSON не прочитан');
+        }
+      } finally {
+        input.value = '';
+      }
+    };
+    reader.readAsText(file);
+  }
+
+  function bindFileButton(buttonId, inputId) {
+    var button = field(buttonId);
+    var input = field(inputId);
+    if (!button || !input || button.dataset.mappingBound === 'true') return;
+    button.dataset.mappingBound = 'true';
+    button.addEventListener('click', function(event) {
+      event.preventDefault();
+      input.click();
+    });
+  }
+
+  function bindOnce(id, eventName, handler) {
+    var element = field(id);
+    if (!element || element.dataset.mappingBound === 'true') return;
+    element.dataset.mappingBound = 'true';
+    element.addEventListener(eventName, handler);
+  }
+
+  function initializeMappingBuilder() {
+    bindOnce('wizard-add-request-mapping-row', 'click', function(event) {
+      event.preventDefault();
+      field('wizard-request-mapping-rows').appendChild(createRequestRow({
+        input: '',
+        target: defaultTargetKind(),
+        apiName: '',
+      }));
+    });
+    bindOnce('wizard-add-response-mapping-row', 'click', function(event) {
+      event.preventDefault();
+      field('wizard-response-mapping-rows').appendChild(createResponseRow({
+        responsePath: '',
+        output: '',
+      }));
+    });
+    bindOnce('wizard-auto-request-mapping', 'click', function(event) {
+      event.preventDefault();
+      renderRequestRows(suggestedRequestRows());
+    });
+    bindOnce('wizard-auto-response-mapping', 'click', function(event) {
+      event.preventDefault();
+      renderResponseRows(suggestedResponseRows());
+      renderResponseTree();
+    });
+    bindOnce('wizard-sync-request-mapping', 'click', function(event) {
+      event.preventDefault();
+      syncVisualMappingsToYaml();
+    });
+    bindOnce('wizard-sync-response-mapping', 'click', function(event) {
+      event.preventDefault();
+      syncVisualMappingsToYaml();
+    });
+    bindOnce('wizard-format-samples', 'click', function(event) {
+      event.preventDefault();
+      formatSamplesAndInferSchemas();
+    });
+
+    bindFileButton('wizard-load-input-sample-file', 'wizard-input-sample-file');
+    bindFileButton('wizard-load-output-sample-file', 'wizard-output-sample-file');
+    bindOnce('wizard-input-sample-file', 'change', function() {
+      loadJsonFile('wizard-input-sample-file', 'wizard-input-sample', function() {
+        renderRequestRows(suggestedRequestRows());
+      });
+    });
+    bindOnce('wizard-output-sample-file', 'change', function() {
+      loadJsonFile('wizard-output-sample-file', 'wizard-output-sample', function() {
+        renderResponseRows(suggestedResponseRows());
+        renderResponseTree();
+      });
+    });
+
+    ['wizard-input-sample', 'tool-input-schema', 'endpoint-path'].forEach(function(id) {
+      var element = field(id);
+      if (!element || element.dataset.mappingRefreshBound === 'true') return;
+      element.dataset.mappingRefreshBound = 'true';
+      element.addEventListener('change', function() {
+        renderRequestRows(requestRowsFromEditor());
+        renderMappingWarnings();
+      });
+    });
+    ['wizard-output-sample', 'tool-output-schema'].forEach(function(id) {
+      var element = field(id);
+      if (!element || element.dataset.mappingRefreshBound === 'true') return;
+      element.dataset.mappingRefreshBound = 'true';
+      element.addEventListener('change', function() {
+        renderResponseRows(responseRowsFromEditor());
+        renderResponseTree();
+        renderMappingWarnings();
+      });
+    });
+
+    renderRequestRows(requestRowsFromEditor());
+    renderResponseRows(responseRowsFromEditor());
+    renderResponseTree();
+    renderMappingWarnings();
+  }
+
+  window.CrankWizardMapping = {
+    initialize: initializeMappingBuilder,
+    sync: syncVisualMappingsToYaml,
+    renderFromEditors: function() {
+      suspendSync = true;
+      renderRequestRows(requestRowsFromEditor());
+      renderResponseRows(responseRowsFromEditor());
+      suspendSync = false;
+      syncVisualMappingsToYaml();
+      renderResponseTree();
+      renderMappingWarnings();
+    },
+    formatSamplesAndInferSchemas: formatSamplesAndInferSchemas,
+    renderWarnings: renderMappingWarnings,
+  };
+})();

apps/ui/js/wizard-model.js

@@ -122,26 +122,76 @@ function preserveMappingRuleMetadata(rule, existingRule) {
   return rule;
 }
 
+function mappingEntrySource(entry) {
+  if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+    return entry.source;
+  }
+  return entry;
+}
+
+function normalizeTransformKind(value) {
+  if (!value) return null;
+  var kind = value && typeof value === 'object' ? value.kind : value;
+  kind = String(kind || '').trim();
+  var allowed = [
+    'identity',
+    'to_string',
+    'to_number',
+    'to_boolean',
+    'join',
+    'split',
+    'wrap_array',
+    'unwrap_singleton',
+  ];
+  return allowed.indexOf(kind) >= 0 ? kind : null;
+}
+
+function applyMappingEntryMetadata(rule, entry, existingRule) {
+  preserveMappingRuleMetadata(rule, existingRule);
+
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+    return rule;
+  }
+
+  if (Object.prototype.hasOwnProperty.call(entry, 'required')) {
+    rule.required = entry.required !== false;
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, 'default_value')) {
+    rule.default_value = entry.default_value;
+  }
+  if (entry.transform !== undefined && entry.transform !== null) {
+    var transformKind = normalizeTransformKind(entry.transform);
+    if (transformKind) rule.transform = { kind: transformKind };
+  }
+  ['condition', 'notes'].forEach(function(field) {
+    if (entry[field] !== undefined && entry[field] !== null) {
+      rule[field] = entry[field];
+    }
+  });
+  return rule;
+}
+
 function buildMappingSet(rawValue, mode) {
   var value = rawValue || {};
   var rules = [];
 
   Object.keys(value).forEach(function(target) {
-    var source = value[target];
+    var entry = value[target];
+    var source = mappingEntrySource(entry);
     if (mode === 'input') {
       var inputTarget = normalizeInputTarget(target);
-      rules.push(preserveMappingRuleMetadata({
+      rules.push(applyMappingEntryMetadata({
         source: normalizeInputSource(source),
         target: inputTarget,
-      }, existingMappingRuleByTarget(mode, inputTarget)));
+      }, entry, existingMappingRuleByTarget(mode, inputTarget)));
       return;
     }
 
     var outputTarget = normalizeOutputTarget(target);
-    rules.push(preserveMappingRuleMetadata({
+    rules.push(applyMappingEntryMetadata({
       source: normalizeOutputSource(source),
       target: outputTarget,
-    }, existingMappingRuleByTarget(mode, outputTarget)));
+    }, entry, existingMappingRuleByTarget(mode, outputTarget)));
   });
 
   return { rules: rules };
@@ -313,11 +363,52 @@ function mappingSetToEditorValue(mappingSet, mode, protocol) {
       var key = rule.target.indexOf(mappingRootForProtocol(protocol) + '.') === 0
         ? rule.target.replace(mappingRootForProtocol(protocol) + '.', '')
         : rule.target.replace('$.request.', '');
-      object[key] = rule.source.replace('$.mcp.', '$.input.');
+      var inputSource = rule.source.replace('$.mcp.', '$.input.');
+      var inputEntry = { source: inputSource };
+      var hasMetadata = false;
+      if (rule.required === false) {
+        inputEntry.required = false;
+        hasMetadata = true;
+      }
+      if (rule.default_value !== undefined && rule.default_value !== null) {
+        inputEntry.default_value = rule.default_value;
+        hasMetadata = true;
+      }
+      if (rule.transform && rule.transform.kind) {
+        inputEntry.transform = rule.transform.kind;
+        hasMetadata = true;
+      }
+      ['condition', 'notes'].forEach(function(field) {
+        if (rule[field] !== undefined && rule[field] !== null) {
+          inputEntry[field] = rule[field];
+          hasMetadata = true;
+        }
+      });
+      object[key] = hasMetadata ? inputEntry : inputSource;
       return;
     }
     var outputKey = rule.target.replace('$.output.', '');
-    object[outputKey] = rule.source;
+    var outputEntry = { source: rule.source };
+    var outputHasMetadata = false;
+    if (rule.required === false) {
+      outputEntry.required = false;
+      outputHasMetadata = true;
+    }
+    if (rule.default_value !== undefined && rule.default_value !== null) {
+      outputEntry.default_value = rule.default_value;
+      outputHasMetadata = true;
+    }
+    if (rule.transform && rule.transform.kind) {
+      outputEntry.transform = rule.transform.kind;
+      outputHasMetadata = true;
+    }
+    ['condition', 'notes'].forEach(function(field) {
+      if (rule[field] !== undefined && rule[field] !== null) {
+        outputEntry[field] = rule[field];
+        outputHasMetadata = true;
+      }
+    });
+    object[outputKey] = outputHasMetadata ? outputEntry : rule.source;
   });
   return window.jsyaml ? window.jsyaml.dump(object, { lineWidth: -1 }) : JSON.stringify(object, null, 2);
 }
@@ -338,6 +429,13 @@ function executionConfigToEditorValue(config) {
   return window.jsyaml ? window.jsyaml.dump(value, { lineWidth: -1 }) : JSON.stringify(value, null, 2);
 }
 
+function setApprovalPolicyFromSnapshot(config) {
+  if (!window.CrankWizardLive || typeof window.CrankWizardLive.setApprovalPolicyEditor !== 'function') {
+    return;
+  }
+  window.CrankWizardLive.setApprovalPolicyEditor(config && config.approval_policy ? config.approval_policy : null);
+}
+
 function operationSnapshot(versionDocument) {
   if (!versionDocument) return {};
   return versionDocument.snapshot || versionDocument;
@@ -396,7 +494,11 @@ function prefillWizardFromEdit(detail, versionDocument) {
   setValue('tool-input-mapping', mappingSetToEditorValue(snapshot.input_mapping, 'input', snapshot.protocol || detail.protocol));
   setValue('tool-output-mapping', mappingSetToEditorValue(snapshot.output_mapping, 'output', snapshot.protocol || detail.protocol));
   setValue('tool-exec-config', executionConfigToEditorValue(snapshot.execution_config || {}));
+  setApprovalPolicyFromSnapshot(snapshot.execution_config || {});
   prefillWizardSamples(snapshot);
+  if (window.CrankWizardMapping && typeof window.CrankWizardMapping.renderFromEditors === 'function') {
+    window.CrankWizardMapping.renderFromEditors();
+  }
 
   var toolNameInput = document.getElementById('tool-name');
   if (toolNameInput) toolNameInput.disabled = true;

apps/ui/package-lock.json

@@ -6,18 +6,18 @@
     "": {
       "name": "crank-ui",
       "dependencies": {
-        "alpinejs": "3.15.9",
-        "js-yaml": "4.1.1"
+        "alpinejs": "3.15.12",
+        "js-yaml": "5.2.1"
       },
       "devDependencies": {
-        "@playwright/test": "^1.59.1",
-        "esbuild": "^0.28.0"
+        "@playwright/test": "1.61.1",
+        "esbuild": "0.28.1"
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.0.tgz",
-      "integrity": "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
+      "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
       "cpu": [
         "ppc64"
       ],
@@ -32,9 +32,9 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.0.tgz",
-      "integrity": "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
+      "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
       "cpu": [
         "arm"
       ],
@@ -49,9 +49,9 @@
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.0.tgz",
-      "integrity": "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
+      "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
       "cpu": [
         "arm64"
       ],
@@ -66,9 +66,9 @@
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.0.tgz",
-      "integrity": "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
+      "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
       "cpu": [
         "x64"
       ],
@@ -83,9 +83,9 @@
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.0.tgz",
-      "integrity": "sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
+      "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
       "cpu": [
         "arm64"
       ],
@@ -100,9 +100,9 @@
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.0.tgz",
-      "integrity": "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
+      "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
       "cpu": [
         "x64"
       ],
@@ -117,9 +117,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
       "cpu": [
         "arm64"
       ],
@@ -134,9 +134,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.0.tgz",
-      "integrity": "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
       "cpu": [
         "x64"
       ],
@@ -151,9 +151,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.0.tgz",
-      "integrity": "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
+      "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
       "cpu": [
         "arm"
       ],
@@ -168,9 +168,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.0.tgz",
-      "integrity": "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
+      "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
       "cpu": [
         "arm64"
       ],
@@ -185,9 +185,9 @@
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.0.tgz",
-      "integrity": "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
+      "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
       "cpu": [
         "ia32"
       ],
@@ -202,9 +202,9 @@
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.0.tgz",
-      "integrity": "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
+      "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
       "cpu": [
         "loong64"
       ],
@@ -219,9 +219,9 @@
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.0.tgz",
-      "integrity": "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
+      "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
       "cpu": [
         "mips64el"
       ],
@@ -236,9 +236,9 @@
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.0.tgz",
-      "integrity": "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
+      "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
       "cpu": [
         "ppc64"
       ],
@@ -253,9 +253,9 @@
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.0.tgz",
-      "integrity": "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
+      "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
       "cpu": [
         "riscv64"
       ],
@@ -270,9 +270,9 @@
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.0.tgz",
-      "integrity": "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
+      "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
       "cpu": [
         "s390x"
       ],
@@ -287,9 +287,9 @@
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.0.tgz",
-      "integrity": "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
+      "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
       "cpu": [
         "x64"
       ],
@@ -304,9 +304,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
       "cpu": [
         "arm64"
       ],
@@ -321,9 +321,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.0.tgz",
-      "integrity": "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
       "cpu": [
         "x64"
       ],
@@ -338,9 +338,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
       "cpu": [
         "arm64"
       ],
@@ -355,9 +355,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.0.tgz",
-      "integrity": "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
       "cpu": [
         "x64"
       ],
@@ -372,9 +372,9 @@
       }
     },
     "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.0.tgz",
-      "integrity": "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
+      "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
       "cpu": [
         "arm64"
       ],
@@ -389,9 +389,9 @@
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.0.tgz",
-      "integrity": "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
+      "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
       "cpu": [
         "x64"
       ],
@@ -406,9 +406,9 @@
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.0.tgz",
-      "integrity": "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
+      "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
       "cpu": [
         "arm64"
       ],
@@ -423,9 +423,9 @@
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.0.tgz",
-      "integrity": "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
+      "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
       "cpu": [
         "ia32"
       ],
@@ -440,9 +440,9 @@
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.0.tgz",
-      "integrity": "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
+      "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
       "cpu": [
         "x64"
       ],
@@ -457,13 +457,13 @@
       }
     },
     "node_modules/@playwright/test": {
-      "version": "1.59.1",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.59.1.tgz",
-      "integrity": "sha512-PG6q63nQg5c9rIi4/Z5lR5IVF7yU5MqmKaPOe0HSc0O2cX1fPi96sUQu5j7eo4gKCkB2AnNGoWt7y4/Xx3Kcqg==",
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.61.1.tgz",
+      "integrity": "sha512-8nKv6+0RJSL9FE4jYOEGXnPeM/Hg12qZpmqzZjRh3qM0Y7c3z1mrOTfFLids72RDQYVh9WpLEfR5WdpNX4fkig==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "playwright": "1.59.1"
+        "playwright": "1.61.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -488,9 +488,9 @@
       "license": "MIT"
     },
     "node_modules/alpinejs": {
-      "version": "3.15.9",
-      "resolved": "https://registry.npmjs.org/alpinejs/-/alpinejs-3.15.9.tgz",
-      "integrity": "sha512-O30m8Tw/aARbLXmeTnISAFgrNm0K71PT7bZy/1NgRqFD36QGb34VJ4a6WBL1iIO/bofN+LkIkKLikUTkfPL2wQ==",
+      "version": "3.15.12",
+      "resolved": "https://registry.npmjs.org/alpinejs/-/alpinejs-3.15.12.tgz",
+      "integrity": "sha512-nJvPAQVNPdZZ0NrExJ/kzQco3ijR8LwvCOadQecllESiqT4NyZ/57sN9V2XyvhlBGAbmlKYgeWZvYdKq99ij/Q==",
       "license": "MIT",
       "dependencies": {
         "@vue/reactivity": "~3.1.1"
@@ -503,9 +503,9 @@
       "license": "Python-2.0"
     },
     "node_modules/esbuild": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.0.tgz",
-      "integrity": "sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+      "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -516,32 +516,32 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.28.0",
-        "@esbuild/android-arm": "0.28.0",
-        "@esbuild/android-arm64": "0.28.0",
-        "@esbuild/android-x64": "0.28.0",
-        "@esbuild/darwin-arm64": "0.28.0",
-        "@esbuild/darwin-x64": "0.28.0",
-        "@esbuild/freebsd-arm64": "0.28.0",
-        "@esbuild/freebsd-x64": "0.28.0",
-        "@esbuild/linux-arm": "0.28.0",
-        "@esbuild/linux-arm64": "0.28.0",
-        "@esbuild/linux-ia32": "0.28.0",
-        "@esbuild/linux-loong64": "0.28.0",
-        "@esbuild/linux-mips64el": "0.28.0",
-        "@esbuild/linux-ppc64": "0.28.0",
-        "@esbuild/linux-riscv64": "0.28.0",
-        "@esbuild/linux-s390x": "0.28.0",
-        "@esbuild/linux-x64": "0.28.0",
-        "@esbuild/netbsd-arm64": "0.28.0",
-        "@esbuild/netbsd-x64": "0.28.0",
-        "@esbuild/openbsd-arm64": "0.28.0",
-        "@esbuild/openbsd-x64": "0.28.0",
-        "@esbuild/openharmony-arm64": "0.28.0",
-        "@esbuild/sunos-x64": "0.28.0",
-        "@esbuild/win32-arm64": "0.28.0",
-        "@esbuild/win32-ia32": "0.28.0",
-        "@esbuild/win32-x64": "0.28.0"
+        "@esbuild/aix-ppc64": "0.28.1",
+        "@esbuild/android-arm": "0.28.1",
+        "@esbuild/android-arm64": "0.28.1",
+        "@esbuild/android-x64": "0.28.1",
+        "@esbuild/darwin-arm64": "0.28.1",
+        "@esbuild/darwin-x64": "0.28.1",
+        "@esbuild/freebsd-arm64": "0.28.1",
+        "@esbuild/freebsd-x64": "0.28.1",
+        "@esbuild/linux-arm": "0.28.1",
+        "@esbuild/linux-arm64": "0.28.1",
+        "@esbuild/linux-ia32": "0.28.1",
+        "@esbuild/linux-loong64": "0.28.1",
+        "@esbuild/linux-mips64el": "0.28.1",
+        "@esbuild/linux-ppc64": "0.28.1",
+        "@esbuild/linux-riscv64": "0.28.1",
+        "@esbuild/linux-s390x": "0.28.1",
+        "@esbuild/linux-x64": "0.28.1",
+        "@esbuild/netbsd-arm64": "0.28.1",
+        "@esbuild/netbsd-x64": "0.28.1",
+        "@esbuild/openbsd-arm64": "0.28.1",
+        "@esbuild/openbsd-x64": "0.28.1",
+        "@esbuild/openharmony-arm64": "0.28.1",
+        "@esbuild/sunos-x64": "0.28.1",
+        "@esbuild/win32-arm64": "0.28.1",
+        "@esbuild/win32-ia32": "0.28.1",
+        "@esbuild/win32-x64": "0.28.1"
       }
     },
     "node_modules/fsevents": {
@@ -560,25 +560,35 @@
       }
     },
     "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-5.2.1.tgz",
+      "integrity": "sha512-zfLtNfQqxVqq3uaTqSkh4x4hZw3KHobGUA0fJUj4wawW8bsQLTVqpHdXSIzidh7o+4lEW36tANuAGdaFx6Zgnw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
       },
       "bin": {
-        "js-yaml": "bin/js-yaml.js"
+        "js-yaml": "bin/js-yaml.mjs"
       }
     },
     "node_modules/playwright": {
-      "version": "1.59.1",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.59.1.tgz",
-      "integrity": "sha512-C8oWjPR3F81yljW9o5OxcWzfh6avkVwDD2VYdwIGqTkl+OGFISgypqzfu7dOe4QNLL2aqcWBmI3PMtLIK233lw==",
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.1.tgz",
+      "integrity": "sha512-DWnY5o3YbLWK4GovuAVwpqL+1VwGNdUGrRr++8j8PtQQzvAVZUIMjKQ90fY689sEJZJBbZVw1rXaOKSTitkzPQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "playwright-core": "1.59.1"
+        "playwright-core": "1.61.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -591,9 +601,9 @@
       }
     },
     "node_modules/playwright-core": {
-      "version": "1.59.1",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.59.1.tgz",
-      "integrity": "sha512-HBV/RJg81z5BiiZ9yPzIiClYV/QMsDCKUyogwH9p3MCP6IYjUFu/MActgYAvK0oWyV9NlwM3GLBjADyWgydVyg==",
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.61.1.tgz",
+      "integrity": "sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {

apps/ui/package.json

@@ -8,11 +8,11 @@
     "e2e:headed": "playwright test --headed"
   },
   "dependencies": {
-    "alpinejs": "3.15.9",
-    "js-yaml": "4.1.1"
+    "alpinejs": "3.15.12",
+    "js-yaml": "5.2.1"
   },
   "devDependencies": {
-    "@playwright/test": "^1.59.1",
-    "esbuild": "^0.28.0"
+    "@playwright/test": "1.61.1",
+    "esbuild": "0.28.1"
   }
 }

apps/ui/scripts/build.js

@@ -41,6 +41,7 @@ const BUNDLES = {
   operations: {
     files: [
       'node_modules/alpinejs/dist/cdn.min.js',
+      'js/openapi-import.js',
       'js/catalog.js',
     ],
   },
@@ -88,11 +89,12 @@ const BUNDLES = {
   },
   wizard: {
     files: [
-      'node_modules/js-yaml/dist/js-yaml.min.js',
+      'node_modules/js-yaml/dist/browser/js-yaml.umd.min.js',
       'js/wizard-state.js',
       'js/wizard-shell.js',
       'js/wizard-upstreams.js',
       'js/wizard-model.js',
+      'js/wizard-mapping.js',
       'js/wizard-live.js',
       'js/wizard.js',
       'js/nav.js',

apps/ui/tests/e2e/api-keys.spec.js

@@ -22,8 +22,25 @@ test('api keys page opens create key flow', async ({ page }) => {
   await expect(page.locator('#btn-create-key')).toBeEnabled();
   await page.locator('#btn-create-key').click();
   await expect(page.locator('#modal-create')).toHaveClass(/open/);
-  await expect(page.locator('.modal-title')).toHaveText(localized('Create agent key', 'Создать ключ агента'));
+  await expect(page.locator('.modal-title')).toHaveText(localized('Create MCP client key', 'Создать ключ MCP-клиента'));
   await page.locator('#new-key-name').fill(`playwright-${Date.now()}`);
   await page.locator('#modal-confirm-btn').click();
   await expect(page.locator('#modal-reveal-body')).toContainText(localized('Copy this key now', 'Скопируйте этот ключ сейчас'));
+  await page.locator('#modal-done-btn').click();
+
+  await page.locator('#key-kind-approval').click();
+  await expect(page.locator('#key-kind-hint')).toContainText(
+    localized('human confirmation interface', 'человек подтверждает действие')
+  );
+  await expect(page.locator('#btn-create-key')).toContainText(
+    localized('Create approval key', 'Создать ключ подтверждения')
+  );
+  await page.locator('#btn-create-key').click();
+  await expect(page.locator('.modal-title')).toHaveText(localized('Create approval key', 'Создать ключ подтверждения'));
+  await expect(page.locator('#approval-key-warning')).toContainText(
+    localized('Do not pass this key to an LLM', 'Не передавайте этот ключ LLM')
+  );
+  await page.locator('#new-key-name').fill(`playwright-approval-${Date.now()}`);
+  await page.locator('#modal-confirm-btn').click();
+  await expect(page.locator('#reveal-key-value')).toContainText('crk_appr_');
 });

apps/ui/tests/e2e/operations.spec.js

@@ -1,5 +1,5 @@
 const { test, expect } = require('@playwright/test');
-const { login, localized } = require('./helpers');
+const { login, localized, uniqueName } = require('./helpers');
 
 test('operations page shows demo catalog and filter works', async ({ page }) => {
   await login(page);
@@ -11,3 +11,109 @@ test('operations page shows demo catalog and filter works', async ({ page }) =>
   await expect(page.locator('tbody tr')).toHaveCount(1);
   await expect(page.locator('tbody tr').first()).toContainText(/frankfurter_latest_rate/i);
 });
+
+test('operations page imports OpenAPI methods as drafts', async ({ page }) => {
+  await login(page);
+  const operationId = uniqueName('get_rates');
+  const statusOperationId = `${operationId}_status`;
+  await page.getByRole('button', { name: /Импорт OpenAPI/i }).click();
+  await expect(page.locator('#openapi-import-modal')).toBeVisible();
+  await page.locator('#openapi-import-document').fill(`
+openapi: 3.0.3
+info:
+  title: Demo Import API
+servers:
+paths:
+  /v1/rates/{date}:
+    post:
+      operationId: ${operationId}
+      summary: Получить курсы валют
+      description: Курсы.
+      tags: [currency]
+      parameters:
+        - name: date
+          in: path
+          required: true
+          schema: { type: string }
+        - name: base
+          in: query
+          required: true
+          schema: { type: string }
+        - name: X-API-Version
+          in: header
+          required: false
+          schema: { type: string }
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [symbols]
+              properties:
+                symbols: { type: string }
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  base: { type: string }
+  /v1/status:
+    get:
+      operationId: ${statusOperationId}
+      summary: Проверить статус
+      tags: [service]
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status: { type: string }
+`);
+  await page.locator('#openapi-import-preview').click();
+  await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
+  await expect(page.locator('.openapi-import-document-findings')).toContainText(/base URL/i);
+  await expect(page.locator('.openapi-import-group').filter({ hasText: 'currency' })).toBeVisible();
+  const importedOperation = page.locator('.openapi-import-operation').filter({ hasText: 'Получить курсы валют' });
+  await expect(importedOperation).toBeVisible();
+  await expect(page.locator('.openapi-import-operation').filter({ hasText: 'Проверить статус' })).toBeVisible();
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('Path');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('date');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('Query');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('base');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('Header');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('X-API-Version');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('Body');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('symbols');
+  await expect(importedOperation.locator('.openapi-import-mapping-preview')).toContainText('Ответ');
+  await expect(page.locator('#openapi-import-selection')).toContainText('Выбрано: 2');
+  await page.locator('#openapi-import-search').fill('status');
+  await expect(page.locator('.openapi-import-operation:visible')).toHaveCount(1);
+  await expect(page.locator('.openapi-import-operation:visible').filter({ hasText: 'Проверить статус' })).toBeVisible();
+  await page.locator('#openapi-import-clear-visible').click();
+  await expect(page.locator('#openapi-import-selection')).toContainText('Выбрано: 1');
+  await page.locator('#openapi-import-search').fill('');
+  await page.locator('#openapi-import-method-filter').selectOption('POST');
+  await expect(page.locator('.openapi-import-operation:visible')).toHaveCount(1);
+  await expect(page.locator('.openapi-import-operation:visible').filter({ hasText: 'Получить курсы валют' })).toBeVisible();
+  await page.locator('#openapi-import-method-filter').selectOption('');
+  await page.locator('#openapi-import-server-custom').fill('https://api.example.test');
+  await page.locator('#openapi-import-create').click();
+  await expect(page.locator('#openapi-import-result')).toContainText('Результат импорта');
+  await expect(page.locator('.openapi-import-result-table')).toBeVisible();
+  await expect(page.locator('.openapi-import-result-row').filter({ hasText: operationId })).toContainText('POST /v1/rates/{date}');
+  await expect(page.locator('.openapi-import-result-row').filter({ hasText: operationId })).toContainText(/Описание инструмента слишком короткое/);
+  await expect(page.locator('.openapi-import-result-row').filter({ hasText: operationId })).toContainText('Исправить в мастере');
+  await expect(page.locator('.openapi-import-primary-result a')).toHaveAttribute(
+    'href',
+    /\/wizard\/\?mode=edit&operationId=op_/
+  );
+  await expect(page.locator('tbody')).toContainText(new RegExp(operationId, 'i'));
+  await expect(page.locator('tbody')).not.toContainText(new RegExp(statusOperationId, 'i'));
+});

apps/ui/tests/e2e/wizard.spec.js

@@ -122,6 +122,7 @@ test('wizard loads reusable upstreams from backend', async ({ page }) => {
   );
 
   await page.goto('/wizard/');
+  await expect(page.locator('#step-panel-1')).toBeVisible();
   await page.locator('[data-testid="wizard-protocol-rest"]').click();
   await page.locator('.btn-continue').click();
   await expect(page.locator('#step-panel-2')).toBeVisible();
@@ -132,6 +133,69 @@ test('wizard loads reusable upstreams from backend', async ({ page }) => {
   await expect(page.locator('#upstream-dropdown-list')).not.toContainText('Open Meteo');
 });
 
+test('wizard builds visual request mappings from JSON sample and path params', async ({ page }) => {
+  await login(page);
+
+  await page.goto('/wizard/');
+  await page.locator('[data-testid="wizard-protocol-rest"]').click();
+  await page.evaluate(() => window.CrankWizardShell.doGoToStep(2));
+  await expect(page.locator('#step-panel-2')).toBeVisible();
+  await page.locator('#endpoint-path').fill('/rates/{date}');
+
+  await page.evaluate(() => window.CrankWizardShell.doGoToStep(3));
+  await expect(page.locator('#step-panel-3-rest')).toBeVisible();
+  await page.locator('.method-card[data-method="GET"]').click();
+
+  await page.evaluate(() => window.CrankWizardShell.doGoToStep(5));
+  await expect(page.locator('#step-panel-5')).toBeVisible();
+
+  await page.locator('#wizard-input-sample').fill(JSON.stringify({
+    date: '2024-01-01',
+    base: 'USD',
+    symbols: 'EUR',
+  }, null, 2));
+  await page.locator('#wizard-output-sample').fill(JSON.stringify({
+    base: 'USD',
+    rates: {
+      EUR: 0.91,
+    },
+    providers: [
+      {
+        name: 'ecb',
+        priority: 1,
+      },
+    ],
+  }, null, 2));
+
+  await page.locator('#wizard-format-samples').click();
+
+  await expect(page.locator('[data-testid="wizard-request-mapping-rows"] [data-role="input"]').first()).toHaveValue('date');
+  await expect(page.locator('[data-testid="wizard-request-mapping-rows"] [data-role="input"]').nth(1)).toHaveValue('base');
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/path\.date/);
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/query\.base/);
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/query\.symbols/);
+  await expect(page.locator('#tool-input-schema')).toHaveValue(/"date"/);
+  await expect(page.locator('#tool-output-schema')).toHaveValue(/"rates"/);
+  await expect(page.locator('[data-testid="wizard-response-json-tree"]')).toContainText('rates.EUR');
+  await expect(page.locator('[data-testid="wizard-response-json-tree"]')).toContainText('providers[0].name');
+  await expect(page.locator('#tool-output-mapping')).toHaveValue(/providers_0_name: \$\.response\.body\.providers\[0\]\.name/);
+  await expect(page.locator('[data-testid="wizard-mapping-warnings"]')).toContainText(/одного элемента массива/);
+
+  await page.locator('#wizard-add-request-mapping-row').click();
+  const defaultRow = page.locator('[data-testid="wizard-request-mapping-rows"] [data-mapping-row="request"]').last();
+  await defaultRow.locator('[data-role="input"]').fill('group');
+  await defaultRow.locator('[data-role="target"]').selectOption('query');
+  await defaultRow.locator('[data-role="apiName"]').fill('group');
+  await defaultRow.locator('[data-role="defaultValue"]').fill('month');
+  await defaultRow.locator('[data-role="transform"]').selectOption('to_string');
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/query\.group:/);
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/default_value: month/);
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/transform: to_string/);
+
+  await page.locator('[data-testid="wizard-request-mapping-rows"] .mapping-row-remove').first().click();
+  await expect(page.locator('[data-testid="wizard-mapping-warnings"]')).toContainText(/date/);
+});
+
 test('wizard edit mode hydrates fields from operation version snapshot', async ({ page }) => {
   await login(page);
   const workspace = await getCurrentWorkspace(page);
@@ -301,6 +365,15 @@ test('wizard edit mode hydrates fields from operation version snapshot', async (
                 from: 'GBP',
                 to: 'USD',
               },
+              import_findings: [
+                {
+                  severity: 'warning',
+                  code: 'openapi_import.weak_tool_description',
+                  message: 'Описание инструмента слишком короткое или техническое.',
+                  suggested_action: 'Уточните, когда агент должен вызывать инструмент.',
+                  field_path: 'GET /rates',
+                },
+              ],
             },
             samples: [],
             generated_draft: null,
@@ -338,6 +411,13 @@ test('wizard edit mode hydrates fields from operation version snapshot', async (
   await expect(page.locator('#wizard-test-input')).toHaveValue(/"from": "GBP"/);
   await expect(page.locator('#wizard-test-input')).toHaveValue(/"to": "USD"/);
   await expect(page.locator('#wizard-test-input')).not.toHaveValue(/Ada/);
+
+  await page.evaluate(() => window.CrankWizardShell.doGoToStep(5));
+  await expect(page.locator('#wizard-quality-findings')).toContainText('Описание инструмента слишком короткое');
+  await expect(page.locator('#wizard-quality-findings')).toContainText('GET /rates');
+  await page.getByRole('button', { name: 'Перейти к описанию' }).click();
+  await expect(page.locator('#step-panel-4')).toBeVisible();
+  await expect(page.locator('#tool-description')).toBeFocused();
 });
 
 test('wizard shows agent-facing MCP preview from current draft fields', async ({ page }) => {
@@ -470,6 +550,13 @@ test('wizard shows agent-facing MCP preview from current draft fields', async ({
               headers: {},
               protocol_options: null,
               streaming: null,
+              approval_policy: {
+                required: true,
+                risk_level: 'financial',
+                ttl_seconds: 180,
+                show_payload_preview: true,
+                payload_preview_mode: 'masked_json',
+              },
             },
             tool_description: {
               title: 'Получить историю курсов за месяц',
@@ -669,6 +756,7 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
                   target: '$.request.query.group',
                   required: false,
                   default_value: 'month',
+                  transform: { kind: 'to_string' },
                 },
               ],
             },
@@ -684,6 +772,13 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
               headers: {},
               protocol_options: null,
               streaming: null,
+              approval_policy: {
+                required: true,
+                risk_level: 'financial',
+                ttl_seconds: 180,
+                show_payload_preview: true,
+                payload_preview_mode: 'masked_json',
+              },
             },
             tool_description: {
               title: 'Получить последний курс',
@@ -706,6 +801,15 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
                 base: 'CHF',
                 symbols: 'JPY',
               },
+              import_findings: [
+                {
+                  severity: 'warning',
+                  code: 'openapi_import.weak_tool_description',
+                  message: 'Описание инструмента слишком короткое или техническое.',
+                  suggested_action: 'Уточните описание.',
+                  field_path: 'GET /latest',
+                },
+              ],
             },
             samples: [],
             generated_draft: null,
@@ -719,6 +823,14 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
   await page.goto(`/wizard/?mode=edit&operationId=${operationId}`);
   await expect(page.locator('#tool-input-mapping')).toHaveValue(/query\.base/);
   await expect(page.locator('#tool-input-mapping')).toHaveValue(/path\.date/);
+  await expect(page.locator('#tool-input-mapping')).toHaveValue(/transform: to_string/);
+  await page.evaluate(() => window.CrankWizardShell.doGoToStep(3));
+  await expect(page.locator('#approval-required')).toBeChecked();
+  await expect(page.locator('#approval-config-fields')).toBeVisible();
+  await expect(page.locator('#approval-mode')).toHaveValue('custom');
+  await expect(page.locator('#approval-risk-level')).toHaveCount(0);
+  await expect(page.locator('#approval-ttl-seconds')).toHaveValue('180');
+  await expect(page.locator('#approval-payload-preview-mode')).toHaveCount(0);
   await page.locator('.btn-save-draft').click();
   await expect.poll(() => updatePayload).not.toBeNull();
 
@@ -744,6 +856,15 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
     headers: {},
     protocol_options: null,
     streaming: null,
+    approval_policy: {
+      required: true,
+      mode: 'custom',
+      risk_level: 'normal',
+      ttl_seconds: 180,
+      show_payload_preview: true,
+      payload_preview_mode: 'summary',
+      elicitation_message: null,
+    },
   });
   expect(updatePayload.tool_description).toEqual({
     title: 'Получить последний курс',
@@ -766,6 +887,15 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
       base: 'CHF',
       symbols: 'JPY',
     },
+    import_findings: [
+      {
+        severity: 'warning',
+        code: 'openapi_import.weak_tool_description',
+        message: 'Описание инструмента слишком короткое или техническое.',
+        suggested_action: 'Уточните описание.',
+        field_path: 'GET /latest',
+      },
+    ],
   });
   expect(updatePayload.input_mapping.rules).toEqual([
     { source: '$.mcp.base', target: '$.request.query.base', required: true },
@@ -776,6 +906,7 @@ test('wizard edit mode preserves explicit request mapping targets on save', asyn
       target: '$.request.query.group',
       required: false,
       default_value: 'month',
+      transform: { kind: 'to_string' },
     },
   ]);
 });

crates/crank-community-auth/src/session_cookie.rs

@@ -1,7 +1,7 @@
 use axum_extra::extract::cookie::{Cookie, CookieJar, SameSite};
 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
 use crank_core::UserSessionId;
-use rand::RngCore;
+use rand::RngExt;
 use sha2::{Digest, Sha256};
 use time::{Duration, OffsetDateTime};
 
@@ -23,7 +23,7 @@ pub enum SessionCookieError {
 pub fn create_session_cookie(session_ttl_hours: i64) -> Result<SessionCookie, SessionCookieError> {
     let session_id = UserSessionId::new(format!("sess_{}", uuid::Uuid::now_v7().simple()));
     let mut secret_bytes = [0_u8; 32];
-    rand::thread_rng().fill_bytes(&mut secret_bytes);
+    rand::rng().fill(&mut secret_bytes);
     let secret = URL_SAFE_NO_PAD.encode(secret_bytes);
     let expires_at = OffsetDateTime::now_utc()
         .checked_add(Duration::hours(session_ttl_hours))

crates/crank-community-mcp/src/access.rs

@@ -27,6 +27,41 @@ pub(super) async fn require_machine_access(
     Ok(credential)
 }
 
+pub(super) async fn require_approval_access(
+    state: &Arc<AppState>,
+    path: &AgentRoutePath,
+    headers: &HeaderMap,
+    required_scope: PlatformApiKeyScope,
+) -> Result<crank_registry::PlatformApiKeyRecord, StatusCode> {
+    let secret = bearer_token(headers).ok_or(StatusCode::UNAUTHORIZED)?;
+    let secret_hash = hash_access_secret(secret);
+    let Some(api_key) = state
+        .registry
+        .get_approval_api_key_by_secret_for_agent_slug(
+            &path.workspace_slug,
+            &path.agent_slug,
+            &secret_hash,
+        )
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+    else {
+        return Err(StatusCode::UNAUTHORIZED);
+    };
+
+    if !approval_allows_scope(&api_key.api_key.scopes, required_scope) {
+        return Err(StatusCode::FORBIDDEN);
+    }
+
+    let used_at = OffsetDateTime::now_utc();
+    state
+        .registry
+        .touch_platform_api_key(&api_key.api_key.workspace_id, &api_key.api_key.id, &used_at)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    Ok(api_key)
+}
+
 pub(super) fn bearer_token(headers: &HeaderMap) -> Option<&str> {
     let value = headers.get(AUTHORIZATION)?.to_str().ok()?;
     let (scheme, token) = value.split_once(' ')?;
@@ -130,9 +165,26 @@ fn allows_scope(scopes: &[PlatformApiKeyScope], required_scope: PlatformApiKeySc
         PlatformApiKeyScope::Deploy => scopes
             .iter()
             .any(|scope| matches!(scope, PlatformApiKeyScope::Deploy)),
+        PlatformApiKeyScope::Approve
+        | PlatformApiKeyScope::Deny
+        | PlatformApiKeyScope::ReadPending => false,
     }
 }
 
+fn approval_allows_scope(
+    scopes: &[PlatformApiKeyScope],
+    required_scope: PlatformApiKeyScope,
+) -> bool {
+    scopes.iter().any(|scope| match required_scope {
+        PlatformApiKeyScope::Approve => matches!(scope, PlatformApiKeyScope::Approve),
+        PlatformApiKeyScope::Deny => matches!(scope, PlatformApiKeyScope::Deny),
+        PlatformApiKeyScope::ReadPending => matches!(scope, PlatformApiKeyScope::ReadPending),
+        PlatformApiKeyScope::Read | PlatformApiKeyScope::Write | PlatformApiKeyScope::Deploy => {
+            false
+        }
+    })
+}
+
 fn security_level_rank(level: OperationSecurityLevel) -> u8 {
     match level {
         OperationSecurityLevel::Standard => 0,

crates/crank-community-mcp/src/app.rs

@@ -10,13 +10,18 @@ use axum::{
     extract::{Path, State},
     http::{HeaderMap, StatusCode},
     response::{IntoResponse, Response, sse::Event},
-    routing::get,
+    routing::{get, post},
 };
 use crank_core::{
-    AuthProfile, CoordinationStateStore, InvocationLevel, InvocationLog, InvocationLogId,
-    InvocationSource, InvocationStatus, PlatformApiKeyScope, SecretId,
+    ApprovalRequest, ApprovalRequestId, ApprovalRequestStatus, AuthProfile, CoordinationStateStore,
+    InvocationLevel, InvocationLog, InvocationLogId, InvocationSource, InvocationStatus,
+    OperationApprovalMode, PlatformApiKeyScope, SecretId,
+};
+use crank_registry::{
+    ApprovalRequestRecord, CreateApprovalRequest, CreateInvocationLogRequest,
+    DecideApprovalRequest, ExpireApprovalRequest, FinishApprovalRequest, PostgresRegistry,
+    PublishedAgentTool,
 };
-use crank_registry::{CreateInvocationLogRequest, PostgresRegistry, PublishedAgentTool};
 use crank_runtime::{
     RequestRateLimiter, ResolvedAuth, RuntimeError, RuntimeExecutionRequest, RuntimeExecutor,
     RuntimeOperation, RuntimeRequestContext, SecretCrypto,
@@ -29,8 +34,8 @@ use tracing::info;
 
 use crate::{
     access::{
-        credential_allows_security_level, require_machine_access, serialize_machine_access_mode,
-        serialize_security_level,
+        credential_allows_security_level, require_approval_access, require_machine_access,
+        serialize_machine_access_mode, serialize_security_level,
     },
     auth::{SharedMachineCredentialVerifier, VerifiedMachineCredential},
     catalog::PublishedToolCatalog,
@@ -74,6 +79,8 @@ pub(super) struct AppState {
 struct InitializeParams {
     #[serde(rename = "protocolVersion")]
     protocol_version: String,
+    #[serde(default)]
+    capabilities: Value,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -83,6 +90,13 @@ struct ToolCallParams {
     arguments: Value,
 }
 
+#[derive(Debug, Deserialize)]
+struct ApprovalDecisionPayload {
+    approve: String,
+    #[serde(default)]
+    note: Option<String>,
+}
+
 #[derive(Clone)]
 struct ResolvedToolCall {
     tool: PublishedAgentTool,
@@ -100,6 +114,13 @@ pub(super) struct AgentRoutePath {
     pub(super) agent_slug: String,
 }
 
+#[derive(Clone, Debug, Deserialize)]
+struct ApprovalRoutePath {
+    workspace_slug: String,
+    agent_slug: String,
+    approval_id: String,
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn build_app(
     registry: PostgresRegistry,
@@ -129,6 +150,22 @@ pub fn build_app(
             "/v1/{workspace_slug}/{agent_slug}",
             get(mcp_get).post(mcp_post).delete(mcp_delete),
         )
+        .route(
+            "/v1/{workspace_slug}/{agent_slug}/approvals",
+            get(list_pending_approvals),
+        )
+        .route(
+            "/v1/{workspace_slug}/{agent_slug}/approvals/{approval_id}/approve",
+            post(approve_request),
+        )
+        .route(
+            "/v1/{workspace_slug}/{agent_slug}/approvals/{approval_id}",
+            get(get_approval_request),
+        )
+        .route(
+            "/v1/{workspace_slug}/{agent_slug}/approvals/{approval_id}/deny",
+            post(deny_request),
+        )
         .with_state(state)
 }
 
@@ -139,6 +176,335 @@ async fn health() -> Json<Value> {
     }))
 }
 
+async fn list_pending_approvals(
+    Path(path): Path<AgentRoutePath>,
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+) -> Response {
+    let key =
+        match require_approval_access(&state, &path, &headers, PlatformApiKeyScope::ReadPending)
+            .await
+        {
+            Ok(key) => key,
+            Err(status) => return status.into_response(),
+        };
+
+    let Some(agent_id) = key.api_key.agent_id.as_ref() else {
+        return StatusCode::FORBIDDEN.into_response();
+    };
+
+    match state
+        .registry
+        .list_pending_approval_requests_for_agent(&key.api_key.workspace_id, agent_id)
+        .await
+    {
+        Ok(items) => Json(json!({ "items": items })).into_response(),
+        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+    }
+}
+
+async fn approve_request(
+    Path(path): Path<ApprovalRoutePath>,
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Json(payload): Json<ApprovalDecisionPayload>,
+) -> Response {
+    decide_approval_request(
+        path,
+        state,
+        headers,
+        payload,
+        PlatformApiKeyScope::Approve,
+        ApprovalRequestStatus::Approved,
+    )
+    .await
+}
+
+async fn get_approval_request(
+    Path(path): Path<ApprovalRoutePath>,
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+) -> Response {
+    let agent_path = AgentRoutePath {
+        workspace_slug: path.workspace_slug,
+        agent_slug: path.agent_slug,
+    };
+    let key = match require_approval_access(
+        &state,
+        &agent_path,
+        &headers,
+        PlatformApiKeyScope::ReadPending,
+    )
+    .await
+    {
+        Ok(key) => key,
+        Err(status) => return status.into_response(),
+    };
+    let Some(agent_id) = key.api_key.agent_id.as_ref() else {
+        return StatusCode::FORBIDDEN.into_response();
+    };
+    let approval_id = ApprovalRequestId::new(path.approval_id);
+
+    approval_record_response(&state, &key.api_key.workspace_id, agent_id, &approval_id).await
+}
+
+async fn deny_request(
+    Path(path): Path<ApprovalRoutePath>,
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Json(payload): Json<ApprovalDecisionPayload>,
+) -> Response {
+    decide_approval_request(
+        path,
+        state,
+        headers,
+        payload,
+        PlatformApiKeyScope::Deny,
+        ApprovalRequestStatus::Denied,
+    )
+    .await
+}
+
+async fn decide_approval_request(
+    path: ApprovalRoutePath,
+    state: Arc<AppState>,
+    headers: HeaderMap,
+    payload: ApprovalDecisionPayload,
+    required_scope: PlatformApiKeyScope,
+    status: ApprovalRequestStatus,
+) -> Response {
+    let agent_path = AgentRoutePath {
+        workspace_slug: path.workspace_slug,
+        agent_slug: path.agent_slug,
+    };
+    let key = match require_approval_access(&state, &agent_path, &headers, required_scope).await {
+        Ok(key) => key,
+        Err(status) => return status.into_response(),
+    };
+
+    if (status == ApprovalRequestStatus::Approved && !payload.approve.eq_ignore_ascii_case("yes"))
+        || (status == ApprovalRequestStatus::Denied && !payload.approve.eq_ignore_ascii_case("no"))
+    {
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(json!({
+                "error": "invalid_decision_payload",
+                "message": "approve must be yes for approve endpoint and no for deny endpoint"
+            })),
+        )
+            .into_response();
+    }
+
+    let Some(agent_id) = key.api_key.agent_id.as_ref() else {
+        return StatusCode::FORBIDDEN.into_response();
+    };
+    let approval_id = ApprovalRequestId::new(path.approval_id);
+
+    match state
+        .registry
+        .decide_approval_request(DecideApprovalRequest {
+            workspace_id: &key.api_key.workspace_id,
+            agent_id,
+            approval_id: &approval_id,
+            status,
+            decided_at: OffsetDateTime::now_utc(),
+            decided_by_key_id: &key.api_key.id,
+            response_payload: Some(json!({ "approve": payload.approve })),
+            decision_note: payload.note.as_deref(),
+        })
+        .await
+    {
+        Ok(Some(record)) if status == ApprovalRequestStatus::Approved => {
+            match execute_approved_request(&state, &agent_path, record).await {
+                Ok(record) => Json(json!(record)).into_response(),
+                Err(response) => response,
+            }
+        }
+        Ok(Some(record)) => Json(json!(record)).into_response(),
+        Ok(None) => {
+            terminal_decision_response(&state, &key.api_key.workspace_id, agent_id, &approval_id)
+                .await
+        }
+        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+    }
+}
+
+async fn approval_record_response(
+    state: &Arc<AppState>,
+    workspace_id: &crank_core::WorkspaceId,
+    agent_id: &crank_core::AgentId,
+    approval_id: &ApprovalRequestId,
+) -> Response {
+    match state
+        .registry
+        .get_approval_request_for_agent(workspace_id, agent_id, approval_id)
+        .await
+    {
+        Ok(Some(record))
+            if record.approval.status == ApprovalRequestStatus::Pending
+                && record.approval.expires_at <= OffsetDateTime::now_utc() =>
+        {
+            expire_approval_response(state, workspace_id, agent_id, approval_id).await
+        }
+        Ok(Some(record)) => Json(json!(record)).into_response(),
+        Ok(None) => StatusCode::NOT_FOUND.into_response(),
+        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+    }
+}
+
+async fn terminal_decision_response(
+    state: &Arc<AppState>,
+    workspace_id: &crank_core::WorkspaceId,
+    agent_id: &crank_core::AgentId,
+    approval_id: &ApprovalRequestId,
+) -> Response {
+    match state
+        .registry
+        .get_approval_request_for_agent(workspace_id, agent_id, approval_id)
+        .await
+    {
+        Ok(Some(record))
+            if record.approval.status == ApprovalRequestStatus::Pending
+                && record.approval.expires_at <= OffsetDateTime::now_utc() =>
+        {
+            expire_approval_response(state, workspace_id, agent_id, approval_id).await
+        }
+        Ok(Some(record))
+            if matches!(
+                record.approval.status,
+                ApprovalRequestStatus::Completed
+                    | ApprovalRequestStatus::Failed
+                    | ApprovalRequestStatus::Denied
+                    | ApprovalRequestStatus::Expired
+            ) =>
+        {
+            Json(json!(record)).into_response()
+        }
+        Ok(Some(_)) => StatusCode::CONFLICT.into_response(),
+        Ok(None) => StatusCode::NOT_FOUND.into_response(),
+        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+    }
+}
+
+async fn expire_approval_response(
+    state: &Arc<AppState>,
+    workspace_id: &crank_core::WorkspaceId,
+    agent_id: &crank_core::AgentId,
+    approval_id: &ApprovalRequestId,
+) -> Response {
+    match state
+        .registry
+        .expire_approval_request(ExpireApprovalRequest {
+            workspace_id,
+            agent_id,
+            approval_id,
+            expired_at: OffsetDateTime::now_utc(),
+        })
+        .await
+    {
+        Ok(Some(record)) => Json(json!(record)).into_response(),
+        Ok(None) => StatusCode::CONFLICT.into_response(),
+        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+    }
+}
+
+async fn execute_approved_request(
+    state: &Arc<AppState>,
+    path: &AgentRoutePath,
+    approval: ApprovalRequestRecord,
+) -> Result<ApprovalRequestRecord, Response> {
+    let tools = state
+        .catalog
+        .list_tools(&path.workspace_slug, &path.agent_slug)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR.into_response())?;
+    let Some(tool) = tools.into_iter().find(|tool| {
+        tool.operation.id == approval.approval.operation_id
+            && tool.operation.version == approval.approval.operation_version
+    }) else {
+        return Err(StatusCode::NOT_FOUND.into_response());
+    };
+
+    let operation = runtime_operation(&tool);
+    let request_preview = build_request_preview(
+        &state.runtime,
+        &operation,
+        &approval.approval.request_payload,
+    );
+    let started_at = Instant::now();
+    let resolved_auth =
+        resolve_operation_auth(state, &tool.workspace_id, &operation.execution_config).await;
+    let result = match resolved_auth {
+        Ok(resolved_auth) => {
+            state
+                .runtime
+                .execute_request(
+                    RuntimeExecutionRequest::new(&operation, &approval.approval.request_payload)
+                        .with_optional_auth(resolved_auth.as_ref()),
+                )
+                .await
+        }
+        Err(error) => Err(error),
+    };
+
+    let (status, response_payload, invocation_status, invocation_level, message, error_kind) =
+        match result {
+            Ok(output) => (
+                ApprovalRequestStatus::Completed,
+                output,
+                InvocationStatus::Ok,
+                InvocationLevel::Info,
+                "approved tool call completed",
+                None,
+            ),
+            Err(error) => (
+                ApprovalRequestStatus::Failed,
+                json!({
+                    "error": {
+                        "code": runtime_error_code(&error),
+                        "message": error.to_string(),
+                    }
+                }),
+                InvocationStatus::Error,
+                InvocationLevel::Error,
+                "approved tool call failed",
+                Some(runtime_error_code(&error)),
+            ),
+        };
+
+    let _ = persist_invocation(
+        state,
+        &tool,
+        InvocationRecord {
+            request_id: Some(approval.approval.id.as_str()),
+            tool_name: &tool.tool_name,
+            status: invocation_status,
+            level: invocation_level,
+            message,
+            status_code: None,
+            error_kind,
+            duration: started_at.elapsed(),
+            request_preview,
+            response_preview: response_payload.clone(),
+        },
+    )
+    .await;
+
+    state
+        .registry
+        .finish_approval_request(FinishApprovalRequest {
+            workspace_id: &approval.approval.workspace_id,
+            agent_id: &approval.approval.agent_id,
+            approval_id: &approval.approval.id,
+            status,
+            response_payload: Some(response_payload),
+            decision_note: None,
+        })
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR.into_response())?
+        .ok_or_else(|| StatusCode::CONFLICT.into_response())
+}
+
 async fn mcp_get(
     Path(path): Path<AgentRoutePath>,
     State(state): State<Arc<AppState>>,
@@ -275,24 +641,23 @@ async fn mcp_post(
         );
     }
 
-    if let Some(session_id) = headers.get(HEADER_MCP_SESSION_ID) {
-        if let Ok(session_id) = session_id.to_str() {
-            let session = match state.sessions.get(session_id).await {
-                Ok(session) => session,
-                Err(_) => {
-                    return with_request_id_header(
-                        StatusCode::INTERNAL_SERVER_ERROR.into_response(),
-                        &transport_request_id,
-                    );
-                }
-            };
-            if let Some(session) = session {
-                if let Err(status) =
-                    validate_session_protocol_version(&headers, &session.protocol_version)
-                {
-                    return with_request_id_header(status.into_response(), &transport_request_id);
-                }
+    if let Some(session_id) = headers.get(HEADER_MCP_SESSION_ID)
+        && let Ok(session_id) = session_id.to_str()
+    {
+        let session = match state.sessions.get(session_id).await {
+            Ok(session) => session,
+            Err(_) => {
+                return with_request_id_header(
+                    StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+                    &transport_request_id,
+                );
             }
+        };
+        if let Some(session) = session
+            && let Err(status) =
+                validate_session_protocol_version(&headers, &session.protocol_version)
+        {
+            return with_request_id_header(status.into_response(), &transport_request_id);
         }
     }
 
@@ -591,6 +956,20 @@ async fn handle_base_tool_call(
     let tool = execution.tool;
     let arguments = execution.arguments;
     let operation = runtime_operation(&tool);
+    if let Some(response) = maybe_handle_approval_policy(
+        &state,
+        session,
+        message,
+        response_mode,
+        &tool,
+        &arguments,
+        transport_request_id,
+    )
+    .await
+    {
+        return response;
+    }
+
     let mut runtime_request_context = RuntimeRequestContext::from_request_id(transport_request_id)
         .with_response_cache_scope(
             tool.workspace_id.as_str().to_owned(),
@@ -674,6 +1053,192 @@ async fn handle_base_tool_call(
     }
 }
 
+async fn maybe_handle_approval_policy(
+    state: &Arc<AppState>,
+    session: &SessionState,
+    message: &Value,
+    response_mode: ResponseMode,
+    tool: &PublishedAgentTool,
+    arguments: &Value,
+    transport_request_id: &str,
+) -> Option<Response> {
+    let policy = tool.operation.execution_config.approval_policy.as_ref()?;
+    if !policy.required {
+        return None;
+    }
+
+    match policy.mode {
+        OperationApprovalMode::Custom => {
+            maybe_create_custom_pending_approval(
+                state,
+                session,
+                message,
+                response_mode,
+                tool,
+                arguments,
+                transport_request_id,
+            )
+            .await
+        }
+        OperationApprovalMode::Elicitation => Some(handle_elicitation_approval(
+            session,
+            message,
+            response_mode,
+            tool,
+            arguments,
+            policy.elicitation_message.as_deref(),
+            transport_request_id,
+        )),
+    }
+}
+
+async fn maybe_create_custom_pending_approval(
+    state: &Arc<AppState>,
+    session: &SessionState,
+    message: &Value,
+    response_mode: ResponseMode,
+    tool: &PublishedAgentTool,
+    arguments: &Value,
+    transport_request_id: &str,
+) -> Option<Response> {
+    let policy = tool.operation.execution_config.approval_policy.as_ref()?;
+
+    let approval_id = ApprovalRequestId::new(format!("approval_{}", uuid::Uuid::now_v7().simple()));
+    let now = OffsetDateTime::now_utc();
+    let expires_at = now + time::Duration::seconds(i64::from(policy.ttl_seconds));
+    let approval_url = approval_url_for(tool, &approval_id);
+    let response_payload = json!({
+        "status": "approval_required",
+        "approval_id": approval_id.as_str(),
+        "approval_url": approval_url,
+        "approve": {
+            "method": "POST",
+            "url": format!("{approval_url}/approve"),
+            "body": { "approve": "yes" }
+        },
+        "deny": {
+            "method": "POST",
+            "url": format!("{approval_url}/deny"),
+            "body": { "approve": "no" }
+        },
+        "expires_at": expires_at,
+        "risk_level": policy.risk_level,
+        "payload_preview": if policy.show_payload_preview {
+            arguments.clone()
+        } else {
+            Value::Null
+        },
+    });
+    let approval = ApprovalRequest {
+        id: approval_id,
+        workspace_id: tool.workspace_id.clone(),
+        agent_id: tool.agent_id.clone(),
+        operation_id: tool.operation.id.clone(),
+        operation_version: tool.operation.version,
+        status: ApprovalRequestStatus::Pending,
+        risk_level: policy.risk_level,
+        request_payload: arguments.clone(),
+        response_payload: None,
+        created_at: now,
+        expires_at,
+        decided_at: None,
+        decided_by_key_id: None,
+        decision_note: None,
+    };
+
+    if let Err(error) = state
+        .registry
+        .create_approval_request(CreateApprovalRequest {
+            approval: &approval,
+        })
+        .await
+    {
+        return Some(internal_jsonrpc_error(message, error));
+    }
+
+    let _ = persist_invocation(
+        state,
+        tool,
+        InvocationRecord {
+            request_id: Some(transport_request_id),
+            tool_name: &tool.tool_name,
+            status: InvocationStatus::Ok,
+            level: InvocationLevel::Info,
+            message: "agent tool call is waiting for human approval",
+            status_code: None,
+            error_kind: None,
+            duration: Duration::from_millis(0),
+            request_preview: arguments.clone(),
+            response_preview: response_payload.clone(),
+        },
+    )
+    .await;
+
+    Some(success_tool_response(
+        message,
+        response_mode,
+        &session.protocol_version,
+        response_payload,
+    ))
+}
+
+fn handle_elicitation_approval(
+    session: &SessionState,
+    message: &Value,
+    response_mode: ResponseMode,
+    tool: &PublishedAgentTool,
+    arguments: &Value,
+    elicitation_message: Option<&str>,
+    transport_request_id: &str,
+) -> Response {
+    if !session.supports_elicitation {
+        return tool_error_response(
+            message,
+            response_mode,
+            &session.protocol_version,
+            generic_tool_error_contract(
+                "approval_elicitation_not_supported",
+                "operation requires MCP Elicitation, but the MCP client did not advertise elicitation capability",
+                transport_request_id,
+                false,
+                Some(
+                    "Выберите Custom MCP Approval или подключите MCP-клиент с поддержкой elicitation.",
+                ),
+            ),
+        );
+    }
+
+    let payload_preview = tool
+        .operation
+        .execution_config
+        .approval_policy
+        .as_ref()
+        .and_then(|policy| policy.show_payload_preview.then(|| arguments.clone()))
+        .unwrap_or(Value::Null);
+
+    success_tool_response(
+        message,
+        response_mode,
+        &session.protocol_version,
+        json!({
+            "status": "elicitation_required",
+            "message": elicitation_message.unwrap_or("Confirm operation execution."),
+            "tool": tool.tool_name,
+            "payload_preview": payload_preview,
+            "note": "This MCP client advertised elicitation support. Full elicitation/create continuation is handled by compatible client integrations.",
+        }),
+    )
+}
+
+fn approval_url_for(tool: &PublishedAgentTool, approval_id: &ApprovalRequestId) -> String {
+    format!(
+        "/v1/{}/{}/approvals/{}",
+        tool.workspace_slug,
+        tool.agent_slug,
+        approval_id.as_str()
+    )
+}
+
 async fn handle_initialize(
     state: Arc<AppState>,
     path: &AgentRoutePath,
@@ -711,12 +1276,17 @@ async fn handle_initialize(
     };
     let now = OffsetDateTime::now_utc();
     let expires_at = add_millis(now, TRANSPORT_SESSION_TTL_MS);
+    let supports_elicitation = initialize_params
+        .capabilities
+        .get("elicitation")
+        .is_some_and(Value::is_object);
     let session_id = match state
         .sessions
         .create(
             protocol_version,
             &path.workspace_slug,
             &path.agent_slug,
+            supports_elicitation,
             now,
             Some(expires_at),
         )

crates/crank-community-mcp/src/session.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, sync::Arc};
 use async_trait::async_trait;
 use crank_registry::PostgresPoolConfig;
 use sqlx::{
-    PgPool,
+    PgPool, Row,
     postgres::{PgConnectOptions, PgPoolOptions},
     query,
 };
@@ -17,6 +17,7 @@ pub struct SessionState {
     pub id: String,
     pub protocol_version: String,
     pub initialized: bool,
+    pub supports_elicitation: bool,
     pub workspace_slug: String,
     pub agent_slug: String,
     pub created_at: OffsetDateTime,
@@ -37,6 +38,7 @@ pub trait TransportSessionStore: Send + Sync {
         protocol_version: &str,
         workspace_slug: &str,
         agent_slug: &str,
+        supports_elicitation: bool,
         now: OffsetDateTime,
         expires_at: Option<OffsetDateTime>,
     ) -> Result<String, SessionStoreError>;
@@ -100,6 +102,7 @@ impl TransportSessionStore for InMemorySessionStore {
         protocol_version: &str,
         workspace_slug: &str,
         agent_slug: &str,
+        supports_elicitation: bool,
         now: OffsetDateTime,
         expires_at: Option<OffsetDateTime>,
     ) -> Result<String, SessionStoreError> {
@@ -112,6 +115,7 @@ impl TransportSessionStore for InMemorySessionStore {
                 id: session_id.clone(),
                 protocol_version: protocol_version.to_owned(),
                 initialized: false,
+                supports_elicitation,
                 workspace_slug: workspace_slug.to_owned(),
                 agent_slug: agent_slug.to_owned(),
                 created_at: now,
@@ -169,6 +173,7 @@ impl TransportSessionStore for PostgresTransportSessionStore {
         protocol_version: &str,
         workspace_slug: &str,
         agent_slug: &str,
+        supports_elicitation: bool,
         now: OffsetDateTime,
         expires_at: Option<OffsetDateTime>,
     ) -> Result<String, SessionStoreError> {
@@ -178,17 +183,19 @@ impl TransportSessionStore for PostgresTransportSessionStore {
                 id,
                 protocol_version,
                 initialized,
+                supports_elicitation,
                 workspace_slug,
                 agent_slug,
                 created_at,
                 updated_at,
                 expires_at
              ) values (
-                $1, $2, false, $3, $4, $5::timestamptz, $5::timestamptz, $6::timestamptz
+                $1, $2, false, $3, $4, $5, $6::timestamptz, $6::timestamptz, $7::timestamptz
              )",
         )
         .bind(&session_id)
         .bind(protocol_version)
+        .bind(supports_elicitation)
         .bind(workspace_slug)
         .bind(agent_slug)
         .bind(now)
@@ -203,20 +210,21 @@ impl TransportSessionStore for PostgresTransportSessionStore {
     }
 
     async fn get(&self, session_id: &str) -> Result<Option<SessionState>, SessionStoreError> {
-        let row = sqlx::query!(
+        let row = sqlx::query(
             "select
                 id,
                 protocol_version,
                 initialized,
+                supports_elicitation,
                 workspace_slug,
                 agent_slug,
-                created_at as \"created_at!: OffsetDateTime\",
-                updated_at as \"updated_at!: OffsetDateTime\",
-                expires_at as \"expires_at: OffsetDateTime\"
+                created_at,
+                updated_at,
+                expires_at
              from mcp_transport_sessions
              where id = $1",
-            session_id,
         )
+        .bind(session_id)
         .fetch_optional(&self.pool)
         .await
         .map_err(|error| SessionStoreError {
@@ -224,14 +232,15 @@ impl TransportSessionStore for PostgresTransportSessionStore {
         })?;
 
         let Some(session) = row.map(|row| SessionState {
-            id: row.id,
-            protocol_version: row.protocol_version,
-            initialized: row.initialized,
-            workspace_slug: row.workspace_slug,
-            agent_slug: row.agent_slug,
-            created_at: row.created_at,
-            updated_at: row.updated_at,
-            expires_at: row.expires_at,
+            id: row.get("id"),
+            protocol_version: row.get("protocol_version"),
+            initialized: row.get("initialized"),
+            supports_elicitation: row.get("supports_elicitation"),
+            workspace_slug: row.get("workspace_slug"),
+            agent_slug: row.get("agent_slug"),
+            created_at: row.get("created_at"),
+            updated_at: row.get("updated_at"),
+            expires_at: row.get("expires_at"),
         }) else {
             return Ok(None);
         };
@@ -291,6 +300,7 @@ async fn apply_postgres_migrations(pool: &PgPool) -> Result<(), SessionStoreErro
             id text primary key,
             protocol_version text not null,
             initialized boolean not null default false,
+            supports_elicitation boolean not null default false,
             workspace_slug text not null,
             agent_slug text not null,
             created_at timestamptz not null,
@@ -304,6 +314,13 @@ async fn apply_postgres_migrations(pool: &PgPool) -> Result<(), SessionStoreErro
         details: error.to_string(),
     })?;
 
+    query("alter table mcp_transport_sessions add column if not exists supports_elicitation boolean not null default false")
+        .execute(pool)
+        .await
+        .map_err(|error| SessionStoreError {
+            details: error.to_string(),
+        })?;
+
     query(
         "alter table mcp_transport_sessions add column if not exists expires_at timestamptz null",
     )

crates/crank-community-mcp/tests/integration/session.rs

@@ -32,6 +32,7 @@ async fn postgres_transport_sessions_survive_store_reconnect() {
             "2025-11-25",
             "default",
             "sales",
+            false,
             created_at,
             Some(created_at + time::Duration::days(30)),
         )
@@ -73,6 +74,7 @@ async fn postgres_transport_sessions_evict_expired_rows_on_read() {
             "2025-11-25",
             "default",
             "sales",
+            false,
             timestamp("2026-05-01T10:00:00Z"),
             Some(timestamp("2026-05-01T10:00:01Z")),
         )

crates/crank-community-mcp/tests/unit/manifest.rs

@@ -106,6 +106,7 @@ fn operation() -> RegistryOperation {
             response_cache: None,
             idempotency: None,
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },

crates/crank-community-mcp/tests/unit/session.rs

@@ -13,7 +13,7 @@ async fn creates_and_reads_transport_sessions() {
     let created_at = timestamp("2026-05-01T10:00:00Z");
 
     let session_id = store
-        .create("2025-11-25", "default", "sales", created_at, None)
+        .create("2025-11-25", "default", "sales", false, created_at, None)
         .await
         .unwrap();
     let session = store.get(&session_id).await.unwrap().unwrap();
@@ -23,6 +23,7 @@ async fn creates_and_reads_transport_sessions() {
     assert_eq!(session.workspace_slug, "default");
     assert_eq!(session.agent_slug, "sales");
     assert!(!session.initialized);
+    assert!(!session.supports_elicitation);
     assert_eq!(session.created_at, created_at);
     assert_eq!(session.updated_at, created_at);
 }
@@ -34,7 +35,7 @@ async fn marks_transport_sessions_initialized() {
     let initialized_at = timestamp("2026-05-01T10:00:05Z");
 
     let session_id = store
-        .create("2025-11-25", "default", "sales", created_at, None)
+        .create("2025-11-25", "default", "sales", false, created_at, None)
         .await
         .unwrap();
 
@@ -61,6 +62,7 @@ async fn drops_expired_in_memory_transport_sessions_on_read() {
             "2025-11-25",
             "default",
             "sales",
+            false,
             created_at,
             Some(expires_at),
         )

crates/crank-core/src/access.rs

@@ -35,12 +35,22 @@ pub enum PlatformApiKeyStatus {
     Revoked,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PlatformApiKeyKind {
+    McpClient,
+    Approval,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PlatformApiKeyScope {
     Read,
     Write,
     Deploy,
+    Approve,
+    Deny,
+    ReadPending,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -82,6 +92,8 @@ pub struct PlatformApiKey {
     pub workspace_id: WorkspaceId,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub agent_id: Option<AgentId>,
+    #[serde(default = "default_platform_api_key_kind")]
+    pub key_kind: PlatformApiKeyKind,
     pub name: String,
     pub prefix: String,
     pub scopes: Vec<PlatformApiKeyScope>,
@@ -90,6 +102,14 @@ pub struct PlatformApiKey {
     pub created_at: OffsetDateTime,
     #[serde(with = "time::serde::rfc3339::option")]
     pub last_used_at: Option<OffsetDateTime>,
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub expires_at: Option<OffsetDateTime>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_origins: Vec<String>,
+}
+
+fn default_platform_api_key_kind() -> PlatformApiKeyKind {
+    PlatformApiKeyKind::McpClient
 }
 
 #[cfg(test)]
@@ -97,7 +117,10 @@ mod tests {
     use serde_json::json;
     use time::{OffsetDateTime, format_description::well_known::Rfc3339};
 
-    use super::{PlatformApiKey, PlatformApiKeyScope, PlatformApiKeyStatus, User, UserStatus};
+    use super::{
+        PlatformApiKey, PlatformApiKeyKind, PlatformApiKeyScope, PlatformApiKeyStatus, User,
+        UserStatus,
+    };
     use crate::ids::{AgentId, PlatformApiKeyId, UserId, WorkspaceId};
 
     #[test]
@@ -138,16 +161,20 @@ mod tests {
             id: PlatformApiKeyId::new("pk_01"),
             workspace_id: WorkspaceId::new("ws_01"),
             agent_id: Some(AgentId::new("agent_01")),
+            key_kind: PlatformApiKeyKind::McpClient,
             name: "Primary".to_owned(),
             prefix: "crk_live".to_owned(),
             scopes: vec![PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
             status: PlatformApiKeyStatus::Active,
             created_at: OffsetDateTime::parse("2026-03-25T12:01:00Z", &Rfc3339).unwrap(),
             last_used_at: Some(OffsetDateTime::parse("2026-03-25T12:05:00Z", &Rfc3339).unwrap()),
+            expires_at: None,
+            allowed_origins: Vec::new(),
         };
 
         let value = serde_json::to_value(&api_key).unwrap();
 
+        assert_eq!(value["key_kind"], json!("mcp_client"));
         assert_eq!(value["created_at"], json!("2026-03-25T12:01:00Z"));
         assert_eq!(value["last_used_at"], json!("2026-03-25T12:05:00Z"));
     }

crates/crank-core/src/approval.rs

@@ -0,0 +1,39 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use time::OffsetDateTime;
+
+use crate::ids::{AgentId, ApprovalRequestId, OperationId, PlatformApiKeyId, WorkspaceId};
+use crate::operation::OperationApprovalRiskLevel;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ApprovalRequestStatus {
+    #[default]
+    Pending,
+    Approved,
+    Denied,
+    Expired,
+    Completed,
+    Failed,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApprovalRequest {
+    pub id: ApprovalRequestId,
+    pub workspace_id: WorkspaceId,
+    pub agent_id: AgentId,
+    pub operation_id: OperationId,
+    pub operation_version: u32,
+    pub status: ApprovalRequestStatus,
+    pub risk_level: OperationApprovalRiskLevel,
+    pub request_payload: Value,
+    pub response_payload: Option<Value>,
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339")]
+    pub expires_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub decided_at: Option<OffsetDateTime>,
+    pub decided_by_key_id: Option<PlatformApiKeyId>,
+    pub decision_note: Option<String>,
+}

crates/crank-core/src/edition.rs

@@ -14,18 +14,13 @@ pub enum MachineAccessMode {
     StaticAgentKey,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 pub enum OperationSecurityLevel {
+    #[default]
     Standard,
 }
 
-impl Default for OperationSecurityLevel {
-    fn default() -> Self {
-        Self::Standard
-    }
-}
-
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct EditionLimits {
     pub max_workspaces: Option<u32>,

crates/crank-core/src/ids.rs

@@ -53,6 +53,7 @@ define_id!(UserSessionId);
 define_id!(AgentId);
 define_id!(InvitationId);
 define_id!(PlatformApiKeyId);
+define_id!(ApprovalRequestId);
 define_id!(InvocationLogId);
 define_id!(AuditEventId);
 define_id!(SecretId);

crates/crank-core/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod access;
 pub mod agent;
+pub mod approval;
 pub mod auth;
 pub mod cache;
 pub mod edition;
@@ -15,9 +16,10 @@ pub mod workspace;
 pub mod domain {
     pub use crate::access::{
         InvitationStatus, InvitationToken, Membership, MembershipRole, PlatformApiKey,
-        PlatformApiKeyScope, PlatformApiKeyStatus, User, UserStatus,
+        PlatformApiKeyKind, PlatformApiKeyScope, PlatformApiKeyStatus, User, UserStatus,
     };
     pub use crate::agent::{Agent, AgentOperationBinding, AgentStatus, AgentVersion};
+    pub use crate::approval::{ApprovalRequest, ApprovalRequestStatus};
     pub use crate::auth::{
         ApiKeyHeaderAuthConfig, ApiKeyQueryAuthConfig, AuthConfig, AuthProfile, BasicAuthConfig,
         BearerAuthConfig,
@@ -31,9 +33,9 @@ pub mod domain {
         ProductEdition,
     };
     pub use crate::ids::{
-        AgentId, AuditEventId, AuthProfileId, DescriptorId, InvitationId, InvocationLogId,
-        OperationId, PlatformApiKeyId, SampleId, SecretId, ToolId, UserId, UserSessionId,
-        WorkspaceId,
+        AgentId, ApprovalRequestId, AuditEventId, AuthProfileId, DescriptorId, InvitationId,
+        InvocationLogId, OperationId, PlatformApiKeyId, SampleId, SecretId, ToolId, UserId,
+        UserSessionId, WorkspaceId,
     };
     pub use crate::observability::{
         InvocationLevel, InvocationLog, InvocationSource, InvocationStatus, UsagePeriod,
@@ -41,9 +43,10 @@ pub mod domain {
     };
     pub use crate::operation::{
         ConfigExport, ConfirmationPolicy, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus,
-        IdempotencyMode, IdempotencyPolicy, Operation, OperationSafetyClass, OperationSafetyPolicy,
-        OperationStatus, ResponseCachePolicy, RestTarget, RetryPolicy, Samples, Target,
-        ToolDescription, ToolExample, WizardState,
+        IdempotencyMode, IdempotencyPolicy, Operation, OperationApprovalMode,
+        OperationApprovalPayloadPreviewMode, OperationApprovalPolicy, OperationApprovalRiskLevel,
+        OperationSafetyClass, OperationSafetyPolicy, OperationStatus, ResponseCachePolicy,
+        RestTarget, RetryPolicy, Samples, Target, ToolDescription, ToolExample, WizardState,
     };
     pub use crate::protocol::{AuthKind, ExportMode, HttpMethod, Protocol};
     pub use crate::secret::{Secret, SecretKind, SecretStatus, SecretVersion};
@@ -85,9 +88,10 @@ pub mod ports {
 
 pub use access::{
     InvitationStatus, InvitationToken, Membership, MembershipRole, PlatformApiKey,
-    PlatformApiKeyScope, PlatformApiKeyStatus, User, UserStatus,
+    PlatformApiKeyKind, PlatformApiKeyScope, PlatformApiKeyStatus, User, UserStatus,
 };
 pub use agent::{Agent, AgentOperationBinding, AgentStatus, AgentVersion};
+pub use approval::{ApprovalRequest, ApprovalRequestStatus};
 pub use auth::{
     ApiKeyHeaderAuthConfig, ApiKeyQueryAuthConfig, AuthConfig, AuthProfile, BasicAuthConfig,
     BearerAuthConfig,
@@ -120,17 +124,19 @@ pub use ext::protocol::{
     SharedProtocolAdapter,
 };
 pub use ids::{
-    AgentId, AuditEventId, AuthProfileId, DescriptorId, InvitationId, InvocationLogId, OperationId,
-    PlatformApiKeyId, SampleId, SecretId, ToolId, UserId, UserSessionId, WorkspaceId,
+    AgentId, ApprovalRequestId, AuditEventId, AuthProfileId, DescriptorId, InvitationId,
+    InvocationLogId, OperationId, PlatformApiKeyId, SampleId, SecretId, ToolId, UserId,
+    UserSessionId, WorkspaceId,
 };
 pub use observability::{
     InvocationLevel, InvocationLog, InvocationSource, InvocationStatus, UsagePeriod, UsageRollup,
 };
 pub use operation::{
     ConfigExport, ConfirmationPolicy, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus,
-    IdempotencyMode, IdempotencyPolicy, Operation, OperationSafetyClass, OperationSafetyPolicy,
-    OperationStatus, ResponseCachePolicy, RestTarget, RetryPolicy, Samples, Target,
-    ToolDescription, ToolExample, WizardState,
+    IdempotencyMode, IdempotencyPolicy, Operation, OperationApprovalMode,
+    OperationApprovalPayloadPreviewMode, OperationApprovalPolicy, OperationApprovalRiskLevel,
+    OperationSafetyClass, OperationSafetyPolicy, OperationStatus, ResponseCachePolicy, RestTarget,
+    RetryPolicy, Samples, Target, ToolDescription, ToolExample, WizardState,
 };
 pub use protocol::{AuthKind, ExportMode, HttpMethod, Protocol};
 pub use secret::{Secret, SecretKind, SecretStatus, SecretVersion};

crates/crank-core/src/operation.rs

@@ -8,6 +8,7 @@ use crate::{
     edition::OperationSecurityLevel,
     ids::{AuthProfileId, OperationId, SampleId},
     protocol::{ExportMode, HttpMethod, Protocol},
+    tool_quality::ToolQualityFinding,
 };
 
 fn default_operation_category() -> String {
@@ -102,6 +103,45 @@ pub struct OperationSafetyPolicy {
     pub confirmation: Option<ConfirmationPolicy>,
 }
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum OperationApprovalRiskLevel {
+    #[default]
+    Normal,
+    Dangerous,
+    Financial,
+    Irreversible,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum OperationApprovalPayloadPreviewMode {
+    #[default]
+    Summary,
+    MaskedJson,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum OperationApprovalMode {
+    #[default]
+    Custom,
+    Elicitation,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct OperationApprovalPolicy {
+    pub required: bool,
+    #[serde(default)]
+    pub mode: OperationApprovalMode,
+    pub risk_level: OperationApprovalRiskLevel,
+    pub ttl_seconds: u32,
+    pub show_payload_preview: bool,
+    pub payload_preview_mode: OperationApprovalPayloadPreviewMode,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub elicitation_message: Option<String>,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct ExecutionConfig {
     pub timeout_ms: u64,
@@ -114,6 +154,8 @@ pub struct ExecutionConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub safety: Option<OperationSafetyPolicy>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub approval_policy: Option<OperationApprovalPolicy>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub auth_profile_ref: Option<AuthProfileId>,
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
     pub headers: BTreeMap<String, String>,
@@ -180,6 +222,8 @@ pub struct WizardState {
     pub output_sample: Option<Value>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub test_input: Option<Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub import_findings: Vec<ToolQualityFinding>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -408,6 +452,7 @@ updated_at: 2026-03-25T08:10:00Z
                 response_cache: None,
                 idempotency: None,
                 safety: None,
+                approval_policy: None,
                 auth_profile_ref: Some(AuthProfileId::new("auth_01")),
                 headers: BTreeMap::new(),
             },

crates/crank-import/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "crank-import"
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+crank-core = { path = "../crank-core" }
+crank-mapping = { path = "../crank-mapping" }
+crank-schema = { path = "../crank-schema" }
+serde.workspace = true
+serde_json.workspace = true
+serde_yaml.workspace = true
+thiserror.workspace = true
+

crates/crank-import/src/lib.rs

@@ -0,0 +1 @@
+pub mod rest;

crates/crank-import/src/rest/mapping.rs

@@ -0,0 +1,79 @@
+use crank_mapping::{MappingRule, MappingSet};
+use crank_schema::{Schema, SchemaKind};
+
+use crate::rest::model::{RestImportParameter, RestParameterLocation};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct BodyFieldMapping {
+    pub input_name: String,
+    pub body_path: String,
+    pub required: bool,
+}
+
+pub fn input_mapping(
+    parameters: &[RestImportParameter],
+    body_fields: &[BodyFieldMapping],
+) -> MappingSet {
+    let mut rules = Vec::new();
+    for parameter in parameters {
+        let target_root = match parameter.location {
+            RestParameterLocation::Path => "$.request.path",
+            RestParameterLocation::Query => "$.request.query",
+            RestParameterLocation::Header => "$.request.headers",
+        };
+        rules.push(MappingRule {
+            source: format!("$.mcp.{}", parameter.name),
+            target: format!("{target_root}.{}", parameter.name),
+            required: parameter.required,
+            default_value: None,
+            transform: None,
+            condition: None,
+            notes: None,
+        });
+    }
+    for field in body_fields {
+        let target = if field.body_path.is_empty() {
+            "$.request.body".to_owned()
+        } else {
+            format!("$.request.body.{}", field.body_path)
+        };
+        rules.push(MappingRule {
+            source: format!("$.mcp.{}", field.input_name),
+            target,
+            required: field.required,
+            default_value: None,
+            transform: None,
+            condition: None,
+            notes: None,
+        });
+    }
+    MappingSet { rules }
+}
+
+pub fn output_mapping(output_schema: &Schema) -> MappingSet {
+    let mut rules = Vec::new();
+    if output_schema.kind == SchemaKind::Object && !output_schema.fields.is_empty() {
+        for (name, field) in &output_schema.fields {
+            rules.push(MappingRule {
+                source: format!("$.response.body.{name}"),
+                target: format!("$.output.{name}"),
+                required: field.required,
+                default_value: None,
+                transform: None,
+                condition: None,
+                notes: None,
+            });
+        }
+    } else {
+        rules.push(MappingRule {
+            source: "$.response.body".to_owned(),
+            target: "$.output".to_owned(),
+            required: true,
+            default_value: None,
+            transform: None,
+            condition: None,
+            notes: None,
+        });
+    }
+    MappingSet { rules }
+}

crates/crank-import/src/rest/mod.rs

@@ -0,0 +1,17 @@
+mod mapping;
+pub mod model;
+mod naming;
+mod normalize;
+mod openapi3;
+mod payload;
+mod recommendations;
+mod schema;
+mod swagger2;
+
+pub use model::{
+    ImportFinding, ImportFindingSeverity, ImportGroupPreview, ImportOperationCandidate,
+    ImportPreview, ImportSourcePreview, RestImportCandidate, RestImportDocument,
+    RestImportOperation, RestImportParameter, RestParameterLocation,
+};
+pub use normalize::preview_document;
+pub use payload::operation_draft_from_candidate;

crates/crank-import/src/rest/model.rs

@@ -0,0 +1,123 @@
+use crank_core::{HttpMethod, RestTarget, ToolDescription, WizardState};
+use crank_mapping::MappingSet;
+use crank_schema::Schema;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ImportFindingSeverity {
+    Info,
+    Warning,
+    Error,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ImportFinding {
+    pub code: String,
+    pub severity: ImportFindingSeverity,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operation_key: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportSourcePreview {
+    pub format: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    pub title: String,
+    #[serde(default)]
+    pub servers: Vec<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportPreview {
+    pub source: ImportSourcePreview,
+    pub groups: Vec<ImportGroupPreview>,
+    #[serde(default)]
+    pub findings: Vec<ImportFinding>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportGroupPreview {
+    pub key: String,
+    pub title: String,
+    pub operations: Vec<ImportOperationCandidate>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportOperationCandidate {
+    pub key: String,
+    pub method: HttpMethod,
+    pub path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operation_id: Option<String>,
+    pub suggested_name: String,
+    pub suggested_display_name: String,
+    pub description: String,
+    pub category: String,
+    pub input_fields: usize,
+    pub output_fields: usize,
+    #[serde(default)]
+    pub server_urls: Vec<String>,
+    #[serde(default)]
+    pub findings: Vec<ImportFinding>,
+    pub draft: RestImportCandidate,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestImportCandidate {
+    pub name: String,
+    pub display_name: String,
+    pub category: String,
+    pub target: RestTarget,
+    pub input_schema: Schema,
+    pub output_schema: Schema,
+    pub input_mapping: MappingSet,
+    pub output_mapping: MappingSet,
+    pub tool_description: ToolDescription,
+    pub wizard_state: Option<WizardState>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RestImportDocument {
+    pub format: String,
+    pub version: Option<String>,
+    pub title: String,
+    pub servers: Vec<String>,
+    pub operations: Vec<RestImportOperation>,
+    pub findings: Vec<ImportFinding>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RestImportOperation {
+    pub key: String,
+    pub method: HttpMethod,
+    pub path: String,
+    pub operation_id: Option<String>,
+    pub summary: Option<String>,
+    pub description: Option<String>,
+    pub tags: Vec<String>,
+    pub parameters: Vec<RestImportParameter>,
+    pub request_body_schema: Option<Value>,
+    pub response_schema: Option<Value>,
+    pub servers: Vec<String>,
+    pub findings: Vec<ImportFinding>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct RestImportParameter {
+    pub name: String,
+    pub location: RestParameterLocation,
+    pub required: bool,
+    pub description: Option<String>,
+    pub schema: Option<Value>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RestParameterLocation {
+    Path,
+    Query,
+    Header,
+}

crates/crank-import/src/rest/naming.rs

@@ -0,0 +1,62 @@
+use std::collections::BTreeSet;
+
+pub fn snake_name(seed: &str) -> String {
+    let mut out = String::new();
+    let mut prev_underscore = false;
+
+    for ch in seed.chars() {
+        if ch.is_ascii_alphanumeric() {
+            if ch.is_ascii_uppercase() && !out.is_empty() && !prev_underscore {
+                out.push('_');
+            }
+            out.push(ch.to_ascii_lowercase());
+            prev_underscore = false;
+        } else if !out.is_empty() && !prev_underscore {
+            out.push('_');
+            prev_underscore = true;
+        }
+    }
+
+    let trimmed = out.trim_matches('_').to_owned();
+    if trimmed.is_empty() {
+        "imported_operation".to_owned()
+    } else if trimmed.chars().next().is_some_and(|ch| ch.is_ascii_digit()) {
+        format!("op_{trimmed}")
+    } else {
+        trimmed
+    }
+}
+
+pub fn unique_name(base: &str, used: &mut BTreeSet<String>) -> String {
+    let clean = snake_name(base);
+    if used.insert(clean.clone()) {
+        return clean;
+    }
+
+    for index in 2.. {
+        let candidate = format!("{clean}_{index}");
+        if used.insert(candidate.clone()) {
+            return candidate;
+        }
+    }
+
+    unreachable!()
+}
+
+pub fn title_from_name(name: &str) -> String {
+    name.split('_')
+        .filter(|part| !part.is_empty())
+        .map(|part| {
+            let mut chars = part.chars();
+            match chars.next() {
+                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+                None => String::new(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+pub fn fallback_operation_seed(method: &str, path: &str) -> String {
+    format!("{method}_{path}")
+}

crates/crank-import/src/rest/normalize.rs

@@ -0,0 +1,111 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use serde_json::Value;
+use thiserror::Error;
+
+use crate::rest::{
+    model::{ImportGroupPreview, ImportPreview, RestImportDocument},
+    openapi3,
+    payload::candidate_from_operation,
+    swagger2,
+};
+
+#[derive(Debug, Error)]
+pub enum ImportParseError {
+    #[error("document is not valid YAML or JSON: {0}")]
+    InvalidDocument(String),
+    #[error("unsupported OpenAPI document")]
+    UnsupportedDocument,
+}
+
+pub fn preview_document(document: &str) -> Result<ImportPreview, ImportParseError> {
+    let yaml: serde_yaml::Value = serde_yaml::from_str(document)
+        .map_err(|error| ImportParseError::InvalidDocument(error.to_string()))?;
+    let root = serde_json::to_value(yaml)
+        .map_err(|error| ImportParseError::InvalidDocument(error.to_string()))?;
+
+    let normalized = if root.get("openapi").is_some() {
+        openapi3::parse_document(&root)?
+    } else if root.get("swagger").and_then(Value::as_str) == Some("2.0") {
+        swagger2::parse_document(&root)?
+    } else {
+        return Err(ImportParseError::UnsupportedDocument);
+    };
+
+    Ok(preview_from_document(normalized))
+}
+
+fn preview_from_document(document: RestImportDocument) -> ImportPreview {
+    let mut groups: BTreeMap<String, ImportGroupPreview> = BTreeMap::new();
+    let mut used_names = BTreeSet::new();
+
+    for operation in &document.operations {
+        let candidate = candidate_from_operation(operation, &document.servers, &mut used_names);
+        let group_title = operation
+            .tags
+            .first()
+            .cloned()
+            .unwrap_or_else(|| "Без группы".to_owned());
+        let group_key = crate::rest::naming::snake_name(&group_title);
+        groups
+            .entry(group_key.clone())
+            .or_insert_with(|| ImportGroupPreview {
+                key: group_key,
+                title: group_title,
+                operations: Vec::new(),
+            })
+            .operations
+            .push(candidate);
+    }
+
+    ImportPreview {
+        source: crate::rest::model::ImportSourcePreview {
+            format: document.format,
+            version: document.version,
+            title: document.title,
+            servers: document.servers,
+        },
+        groups: groups.into_values().collect(),
+        findings: document.findings,
+    }
+}
+
+pub(crate) fn resolve_local_ref(root: &Value, value: &Value, depth: usize) -> Value {
+    if depth > 12 {
+        return value.clone();
+    }
+    if let Some(reference) = value.get("$ref").and_then(Value::as_str) {
+        if let Some(resolved) = pointer(root, reference) {
+            return resolve_local_ref(root, resolved, depth + 1);
+        }
+        return value.clone();
+    }
+    match value {
+        Value::Object(map) => {
+            let mut out = serde_json::Map::new();
+            for (key, item) in map {
+                out.insert(key.clone(), resolve_local_ref(root, item, depth + 1));
+            }
+            Value::Object(out)
+        }
+        Value::Array(items) => Value::Array(
+            items
+                .iter()
+                .map(|item| resolve_local_ref(root, item, depth + 1))
+                .collect(),
+        ),
+        _ => value.clone(),
+    }
+}
+
+fn pointer<'a>(root: &'a Value, reference: &str) -> Option<&'a Value> {
+    if !reference.starts_with("#/") {
+        return None;
+    }
+    let mut current = root;
+    for part in reference.trim_start_matches("#/").split('/') {
+        let part = part.replace("~1", "/").replace("~0", "~");
+        current = current.get(&part)?;
+    }
+    Some(current)
+}

crates/crank-import/src/rest/openapi3.rs

@@ -0,0 +1,228 @@
+use crank_core::HttpMethod;
+use serde_json::Value;
+
+use crate::rest::{
+    model::{
+        ImportFinding, RestImportDocument, RestImportOperation, RestImportParameter,
+        RestParameterLocation,
+    },
+    normalize::{ImportParseError, resolve_local_ref},
+    recommendations::document_finding,
+};
+
+pub fn parse_document(root: &Value) -> Result<RestImportDocument, ImportParseError> {
+    let version = root
+        .get("openapi")
+        .and_then(Value::as_str)
+        .map(ToOwned::to_owned);
+    let title = root
+        .pointer("/info/title")
+        .and_then(Value::as_str)
+        .unwrap_or("Imported API")
+        .to_owned();
+    let servers = root
+        .get("servers")
+        .and_then(Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(|item| item.get("url").and_then(Value::as_str))
+                .map(|url| url.trim_end_matches('/').to_owned())
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    let mut findings = Vec::new();
+    if servers.is_empty() {
+        findings.push(document_finding(
+            "missing_servers",
+            "В документе не указаны servers, base URL нужно будет выбрать вручную.",
+        ));
+    } else if servers.len() > 1 {
+        findings.push(document_finding(
+            "multiple_servers",
+            "В документе несколько servers, при импорте нужно выбрать нужный base URL.",
+        ));
+    }
+
+    let mut operations = Vec::new();
+    let paths = root
+        .get("paths")
+        .and_then(Value::as_object)
+        .ok_or(ImportParseError::UnsupportedDocument)?;
+
+    for (path, path_item) in paths {
+        let path_parameters = parameters(root, path_item.get("parameters"));
+        for method_name in ["get", "post", "put", "patch", "delete"] {
+            let Some(operation_value) = path_item.get(method_name) else {
+                continue;
+            };
+            let Some(method) = method_from_lower(method_name) else {
+                continue;
+            };
+
+            let mut operation_parameters = path_parameters.clone();
+            operation_parameters.extend(parameters(root, operation_value.get("parameters")));
+            let operation_servers = operation_value
+                .get("servers")
+                .and_then(Value::as_array)
+                .map(|items| {
+                    items
+                        .iter()
+                        .filter_map(|item| item.get("url").and_then(Value::as_str))
+                        .map(|url| url.trim_end_matches('/').to_owned())
+                        .collect::<Vec<_>>()
+                })
+                .unwrap_or_default();
+
+            operations.push(RestImportOperation {
+                key: format!("{} {}", method_name.to_uppercase(), path),
+                method,
+                path: path.clone(),
+                operation_id: operation_value
+                    .get("operationId")
+                    .and_then(Value::as_str)
+                    .map(ToOwned::to_owned),
+                summary: operation_value
+                    .get("summary")
+                    .and_then(Value::as_str)
+                    .map(ToOwned::to_owned),
+                description: operation_value
+                    .get("description")
+                    .and_then(Value::as_str)
+                    .map(ToOwned::to_owned),
+                tags: operation_value
+                    .get("tags")
+                    .and_then(Value::as_array)
+                    .map(|items| {
+                        items
+                            .iter()
+                            .filter_map(Value::as_str)
+                            .map(ToOwned::to_owned)
+                            .collect()
+                    })
+                    .unwrap_or_default(),
+                parameters: operation_parameters,
+                request_body_schema: request_body_schema(root, operation_value),
+                response_schema: response_schema(root, operation_value),
+                servers: operation_servers,
+                findings: operation_findings(operation_value),
+            });
+        }
+    }
+
+    Ok(RestImportDocument {
+        format: "openapi".to_owned(),
+        version,
+        title,
+        servers,
+        operations,
+        findings,
+    })
+}
+
+fn parameters(root: &Value, value: Option<&Value>) -> Vec<RestImportParameter> {
+    value
+        .and_then(Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(|item| {
+                    let item = resolve_local_ref(root, item, 0);
+                    let location = match item.get("in").and_then(Value::as_str)? {
+                        "path" => RestParameterLocation::Path,
+                        "query" => RestParameterLocation::Query,
+                        "header" => RestParameterLocation::Header,
+                        _ => return None,
+                    };
+                    Some(RestImportParameter {
+                        name: item.get("name").and_then(Value::as_str)?.to_owned(),
+                        location,
+                        required: item
+                            .get("required")
+                            .and_then(Value::as_bool)
+                            .unwrap_or(false)
+                            || location == RestParameterLocation::Path,
+                        description: item
+                            .get("description")
+                            .and_then(Value::as_str)
+                            .map(ToOwned::to_owned),
+                        schema: item
+                            .get("schema")
+                            .map(|schema| resolve_local_ref(root, schema, 0)),
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn request_body_schema(root: &Value, operation: &Value) -> Option<Value> {
+    let body = resolve_local_ref(root, operation.get("requestBody")?, 0);
+    let content = body.get("content")?.as_object()?;
+    for content_type in ["application/json", "application/*+json"] {
+        if let Some(schema) = content
+            .get(content_type)
+            .and_then(|media| media.get("schema"))
+        {
+            return Some(resolve_local_ref(root, schema, 0));
+        }
+    }
+    content
+        .iter()
+        .find(|(content_type, _)| content_type.contains("json"))
+        .and_then(|(_, media)| media.get("schema"))
+        .map(|schema| resolve_local_ref(root, schema, 0))
+}
+
+fn response_schema(root: &Value, operation: &Value) -> Option<Value> {
+    let responses = operation.get("responses")?.as_object()?;
+    for code in ["200", "201", "202", "default"] {
+        let Some(response) = responses.get(code) else {
+            continue;
+        };
+        let response = resolve_local_ref(root, response, 0);
+        let Some(content) = response.get("content").and_then(Value::as_object) else {
+            continue;
+        };
+        for content_type in ["application/json", "application/*+json"] {
+            if let Some(schema) = content
+                .get(content_type)
+                .and_then(|media| media.get("schema"))
+            {
+                return Some(resolve_local_ref(root, schema, 0));
+            }
+        }
+        if let Some(schema) = content
+            .iter()
+            .find(|(content_type, _)| content_type.contains("json"))
+            .and_then(|(_, media)| media.get("schema"))
+        {
+            return Some(resolve_local_ref(root, schema, 0));
+        }
+    }
+    None
+}
+
+fn operation_findings(operation: &Value) -> Vec<ImportFinding> {
+    let mut findings = Vec::new();
+    if operation.get("requestBody").is_some()
+        && request_body_schema(&Value::Null, operation).is_none()
+    {
+        findings.push(document_finding(
+            "unsupported_request_body",
+            "У метода есть requestBody, но JSON schema не найдена.",
+        ));
+    }
+    findings
+}
+
+fn method_from_lower(value: &str) -> Option<HttpMethod> {
+    match value {
+        "get" => Some(HttpMethod::Get),
+        "post" => Some(HttpMethod::Post),
+        "put" => Some(HttpMethod::Put),
+        "patch" => Some(HttpMethod::Patch),
+        "delete" => Some(HttpMethod::Delete),
+        _ => None,
+    }
+}

crates/crank-import/src/rest/payload.rs

@@ -0,0 +1,243 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use crank_core::{
+    ExecutionConfig, HttpMethod, OperationSafetyClass, OperationSafetyPolicy, Protocol, RestTarget,
+    ToolDescription, ToolExample, WizardState,
+};
+use serde_json::json;
+
+use crate::rest::{
+    mapping::{BodyFieldMapping, input_mapping, output_mapping},
+    model::{
+        ImportOperationCandidate, RestImportCandidate, RestImportOperation, RestParameterLocation,
+    },
+    naming::{fallback_operation_seed, title_from_name, unique_name},
+    recommendations::{candidate_recommendations, operation_recommendations},
+    schema::{any_object, field_count, object_with_fields, schema_from_openapi},
+};
+
+pub fn candidate_from_operation(
+    operation: &RestImportOperation,
+    document_servers: &[String],
+    used_names: &mut BTreeSet<String>,
+) -> ImportOperationCandidate {
+    let method_name = method_as_str(operation.method);
+    let seed = operation
+        .operation_id
+        .as_deref()
+        .filter(|value| !value.trim().is_empty())
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| fallback_operation_seed(method_name, &operation.path));
+    let name = unique_name(&seed, used_names);
+    let display_name = operation
+        .summary
+        .as_deref()
+        .filter(|value| !value.trim().is_empty())
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| title_from_name(&name));
+    let description = operation
+        .description
+        .as_deref()
+        .or(operation.summary.as_deref())
+        .filter(|value| !value.trim().is_empty())
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| format!("Выполняет {method_name} {}", operation.path));
+    let category = operation
+        .tags
+        .first()
+        .cloned()
+        .unwrap_or_else(|| "imported".to_owned());
+    let server_urls = if operation.servers.is_empty() {
+        document_servers.to_vec()
+    } else {
+        operation.servers.clone()
+    };
+    let base_url = server_urls.first().cloned().unwrap_or_default();
+    let mut input_fields = BTreeMap::new();
+    let mut used_input_field_names = BTreeSet::new();
+    for parameter in &operation.parameters {
+        used_input_field_names.insert(parameter.name.clone());
+        input_fields.insert(
+            parameter.name.clone(),
+            schema_from_openapi(
+                parameter.schema.as_ref(),
+                parameter.required || parameter.location == RestParameterLocation::Path,
+                parameter.description.clone(),
+            ),
+        );
+    }
+    let body_fields = body_input_fields(
+        operation.request_body_schema.as_ref(),
+        &mut used_input_field_names,
+        &mut input_fields,
+    );
+    let input_schema = object_with_fields(
+        Some("Входные параметры MCP-инструмента".to_owned()),
+        input_fields,
+    );
+    let output_schema = operation
+        .response_schema
+        .as_ref()
+        .map(|schema| schema_from_openapi(Some(schema), true, Some("Ответ API".to_owned())))
+        .unwrap_or_else(|| any_object(Some("Ответ API".to_owned())));
+    let input_mapping = input_mapping(&operation.parameters, &body_fields);
+    let output_mapping = output_mapping(&output_schema);
+    let mut findings = operation_recommendations(operation);
+    findings.extend(candidate_recommendations(
+        operation,
+        &name,
+        &description,
+        &input_schema,
+        &output_schema,
+    ));
+
+    let draft = RestImportCandidate {
+        name: name.clone(),
+        display_name: display_name.clone(),
+        category: category.clone(),
+        target: RestTarget {
+            base_url,
+            method: operation.method,
+            path_template: operation.path.clone(),
+            static_headers: BTreeMap::new(),
+        },
+        input_schema: input_schema.clone(),
+        output_schema: output_schema.clone(),
+        input_mapping,
+        output_mapping,
+        tool_description: ToolDescription {
+            title: display_name.clone(),
+            description: description.clone(),
+            tags: operation.tags.clone(),
+            examples: vec![ToolExample { input: json!({}) }],
+        },
+        wizard_state: Some(WizardState {
+            input_sample: None,
+            output_sample: None,
+            test_input: None,
+            import_findings: Vec::new(),
+        }),
+    };
+
+    ImportOperationCandidate {
+        key: operation.key.clone(),
+        method: operation.method,
+        path: operation.path.clone(),
+        operation_id: operation.operation_id.clone(),
+        suggested_name: name,
+        suggested_display_name: display_name,
+        description,
+        category,
+        input_fields: field_count(&input_schema),
+        output_fields: field_count(&output_schema),
+        server_urls,
+        findings,
+        draft,
+    }
+}
+
+fn body_input_fields(
+    request_body_schema: Option<&serde_json::Value>,
+    used_names: &mut BTreeSet<String>,
+    input_fields: &mut BTreeMap<String, crank_schema::Schema>,
+) -> Vec<BodyFieldMapping> {
+    let Some(request_body_schema) = request_body_schema else {
+        return Vec::new();
+    };
+    let body_schema = schema_from_openapi(
+        Some(request_body_schema),
+        true,
+        Some("Тело запроса".to_owned()),
+    );
+    if body_schema.kind != crank_schema::SchemaKind::Object || body_schema.fields.is_empty() {
+        let input_name = unique_body_input_name("body", used_names);
+        input_fields.insert(input_name.clone(), body_schema);
+        return vec![BodyFieldMapping {
+            input_name,
+            body_path: String::new(),
+            required: true,
+        }];
+    }
+
+    let mut mappings = Vec::new();
+    for (field_name, field_schema) in body_schema.fields {
+        let input_name = unique_body_input_name(&field_name, used_names);
+        mappings.push(BodyFieldMapping {
+            input_name: input_name.clone(),
+            body_path: field_name,
+            required: field_schema.required,
+        });
+        input_fields.insert(input_name, field_schema);
+    }
+    mappings
+}
+
+fn unique_body_input_name(name: &str, used_names: &mut BTreeSet<String>) -> String {
+    if used_names.insert(name.to_owned()) {
+        return name.to_owned();
+    }
+    let prefixed = format!("body_{name}");
+    if used_names.insert(prefixed.clone()) {
+        return prefixed;
+    }
+    for index in 2.. {
+        let candidate = format!("body_{name}_{index}");
+        if used_names.insert(candidate.clone()) {
+            return candidate;
+        }
+    }
+    unreachable!()
+}
+
+pub fn operation_draft_from_candidate(
+    candidate: &ImportOperationCandidate,
+    server_url: Option<&str>,
+) -> RestImportCandidate {
+    let mut draft = candidate.draft.clone();
+    if let Some(server_url) = server_url.filter(|value| !value.trim().is_empty()) {
+        draft.target.base_url = server_url.trim().trim_end_matches('/').to_owned();
+    }
+    draft
+}
+
+fn method_as_str(method: HttpMethod) -> &'static str {
+    match method {
+        HttpMethod::Get => "GET",
+        HttpMethod::Post => "POST",
+        HttpMethod::Put => "PUT",
+        HttpMethod::Patch => "PATCH",
+        HttpMethod::Delete => "DELETE",
+    }
+}
+
+#[allow(dead_code)]
+fn safety_for_method(method: HttpMethod) -> OperationSafetyPolicy {
+    let class = match method {
+        HttpMethod::Get => OperationSafetyClass::Read,
+        HttpMethod::Post | HttpMethod::Put | HttpMethod::Patch => OperationSafetyClass::Write,
+        HttpMethod::Delete => OperationSafetyClass::Destructive,
+    };
+    OperationSafetyPolicy {
+        class,
+        confirmation: None,
+    }
+}
+
+#[allow(dead_code)]
+fn default_execution_config() -> ExecutionConfig {
+    ExecutionConfig {
+        timeout_ms: 10_000,
+        retry_policy: None,
+        response_cache: None,
+        idempotency: None,
+        safety: None,
+        approval_policy: None,
+        auth_profile_ref: None,
+        headers: BTreeMap::new(),
+    }
+}
+
+#[allow(dead_code)]
+fn _protocol() -> Protocol {
+    Protocol::Rest
+}

crates/crank-import/src/rest/recommendations.rs

@@ -0,0 +1,213 @@
+use crank_schema::{Schema, SchemaKind};
+
+use crate::rest::model::{ImportFinding, ImportFindingSeverity, RestImportOperation};
+
+pub fn document_finding(code: &str, message: impl Into<String>) -> ImportFinding {
+    ImportFinding {
+        code: code.to_owned(),
+        severity: ImportFindingSeverity::Warning,
+        message: message.into(),
+        operation_key: None,
+    }
+}
+
+pub fn operation_finding(
+    operation_key: &str,
+    code: &str,
+    message: impl Into<String>,
+) -> ImportFinding {
+    ImportFinding {
+        code: code.to_owned(),
+        severity: ImportFindingSeverity::Warning,
+        message: message.into(),
+        operation_key: Some(operation_key.to_owned()),
+    }
+}
+
+pub fn operation_info(
+    operation_key: &str,
+    code: &str,
+    message: impl Into<String>,
+) -> ImportFinding {
+    ImportFinding {
+        code: code.to_owned(),
+        severity: ImportFindingSeverity::Info,
+        message: message.into(),
+        operation_key: Some(operation_key.to_owned()),
+    }
+}
+
+pub fn operation_recommendations(operation: &RestImportOperation) -> Vec<ImportFinding> {
+    let mut findings = operation.findings.clone();
+    if operation
+        .operation_id
+        .as_deref()
+        .unwrap_or_default()
+        .trim()
+        .is_empty()
+    {
+        findings.push(operation_finding(
+            &operation.key,
+            "missing_operation_id",
+            "У метода нет operationId, имя инструмента будет сгенерировано из метода и пути.",
+        ));
+    }
+    if operation
+        .summary
+        .as_deref()
+        .unwrap_or_default()
+        .trim()
+        .is_empty()
+    {
+        findings.push(operation_finding(
+            &operation.key,
+            "missing_summary",
+            "У метода нет summary, отображаемое имя будет сгенерировано автоматически.",
+        ));
+    }
+    if operation
+        .description
+        .as_deref()
+        .unwrap_or_default()
+        .trim()
+        .is_empty()
+    {
+        findings.push(operation_finding(
+            &operation.key,
+            "missing_description",
+            "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.",
+        ));
+    }
+    if operation.response_schema.is_none() {
+        findings.push(operation_finding(
+            &operation.key,
+            "missing_response_schema",
+            "У метода не найдена схема успешного ответа, результат будет описан как общий объект.",
+        ));
+    }
+    if operation.parameters.len() > 12 {
+        findings.push(operation_finding(
+            &operation.key,
+            "too_many_inputs",
+            "У метода много входных параметров. Проверьте, не стоит ли разделить инструмент на более узкие сценарии.",
+        ));
+    }
+    let undocumented_parameters = operation
+        .parameters
+        .iter()
+        .filter(|parameter| {
+            parameter
+                .description
+                .as_deref()
+                .unwrap_or_default()
+                .trim()
+                .is_empty()
+        })
+        .count();
+    if undocumented_parameters > 0 {
+        findings.push(operation_finding(
+            &operation.key,
+            "parameter_descriptions_missing",
+            format!(
+                "У {undocumented_parameters} входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать."
+            ),
+        ));
+    }
+    findings
+}
+
+pub fn candidate_recommendations(
+    operation: &RestImportOperation,
+    suggested_name: &str,
+    description: &str,
+    input_schema: &Schema,
+    output_schema: &Schema,
+) -> Vec<ImportFinding> {
+    let mut findings = Vec::new();
+    let input_fields = field_count(input_schema);
+    let output_fields = field_count(output_schema);
+
+    if input_fields == 0 {
+        findings.push(operation_info(
+            &operation.key,
+            "no_input_fields",
+            "У инструмента нет входных параметров. Это нормально для справочных методов, но проверьте, что агенту не нужно передавать фильтры.",
+        ));
+    }
+    if output_fields == 0 {
+        findings.push(operation_finding(
+            &operation.key,
+            "empty_output_schema",
+            "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.",
+        ));
+    }
+    if output_fields > 12 {
+        findings.push(operation_finding(
+            &operation.key,
+            "too_many_output_fields",
+            format!(
+                "В ответ инструмента попадает много полей: {output_fields}. Лучше вернуть только данные, которые нужны агенту для ответа пользователю."
+            ),
+        ));
+    }
+    if is_weak_description(operation, description) {
+        findings.push(operation_finding(
+            &operation.key,
+            "weak_tool_description",
+            "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.",
+        ));
+    }
+    if weak_name(suggested_name) {
+        findings.push(operation_finding(
+            &operation.key,
+            "weak_tool_name",
+            format!(
+                "Имя инструмента `{suggested_name}` выглядит слишком общим. Лучше использовать имя с конкретным действием и объектом."
+            ),
+        ));
+    }
+
+    findings
+}
+
+fn is_weak_description(operation: &RestImportOperation, description: &str) -> bool {
+    let normalized = description.trim();
+    if normalized.chars().count() < 40 {
+        return true;
+    }
+    if normalized.starts_with("Выполняет ") {
+        return true;
+    }
+    operation
+        .summary
+        .as_deref()
+        .map(|summary| summary.trim() == normalized)
+        .unwrap_or(false)
+}
+
+fn weak_name(name: &str) -> bool {
+    let parts = name
+        .split('_')
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>();
+    if parts.len() < 2 {
+        return true;
+    }
+    let weak_terms = [
+        "api",
+        "data",
+        "item",
+        "items",
+        "object",
+        "operation",
+        "request",
+    ];
+    parts.iter().any(|part| weak_terms.contains(part))
+}
+
+fn field_count(schema: &Schema) -> usize {
+    match schema.kind {
+        SchemaKind::Object => schema.fields.len(),
+        _ => 0,
+    }
+}

crates/crank-import/src/rest/schema.rs

@@ -0,0 +1,203 @@
+use std::collections::BTreeMap;
+
+use crank_schema::{Schema, SchemaKind};
+use serde_json::Value;
+
+pub fn any_object(description: Option<String>) -> Schema {
+    Schema {
+        kind: SchemaKind::Object,
+        description,
+        required: true,
+        nullable: false,
+        default_value: None,
+        fields: BTreeMap::new(),
+        items: None,
+        enum_values: Vec::new(),
+        variants: Vec::new(),
+    }
+}
+
+pub fn field_count(schema: &Schema) -> usize {
+    match schema.kind {
+        SchemaKind::Object => schema.fields.len(),
+        _ => 0,
+    }
+}
+
+pub fn schema_from_openapi(
+    value: Option<&Value>,
+    required: bool,
+    description: Option<String>,
+) -> Schema {
+    let Some(value) = value else {
+        return primitive(SchemaKind::String, required, description);
+    };
+    let resolved = collapse_composition(value);
+
+    if let Some(values) = resolved.get("enum").and_then(Value::as_array) {
+        let enum_values = values
+            .iter()
+            .filter_map(Value::as_str)
+            .map(ToOwned::to_owned)
+            .collect::<Vec<_>>();
+        if !enum_values.is_empty() {
+            return Schema {
+                kind: SchemaKind::Enum,
+                description: description.or_else(|| text(&resolved, "description")),
+                required,
+                nullable: nullable(&resolved),
+                default_value: resolved.get("default").cloned(),
+                fields: BTreeMap::new(),
+                items: None,
+                enum_values,
+                variants: Vec::new(),
+            };
+        }
+    }
+
+    match type_name(&resolved).unwrap_or("object") {
+        "object" => object_schema(&resolved, required, description),
+        "array" => Schema {
+            kind: SchemaKind::Array,
+            description: description.or_else(|| text(&resolved, "description")),
+            required,
+            nullable: nullable(&resolved),
+            default_value: resolved.get("default").cloned(),
+            fields: BTreeMap::new(),
+            items: Some(Box::new(schema_from_openapi(
+                resolved.get("items"),
+                true,
+                None,
+            ))),
+            enum_values: Vec::new(),
+            variants: Vec::new(),
+        },
+        "integer" => primitive(
+            SchemaKind::Integer,
+            required,
+            description.or_else(|| text(&resolved, "description")),
+        ),
+        "number" => primitive(
+            SchemaKind::Number,
+            required,
+            description.or_else(|| text(&resolved, "description")),
+        ),
+        "boolean" => primitive(
+            SchemaKind::Boolean,
+            required,
+            description.or_else(|| text(&resolved, "description")),
+        ),
+        "null" => primitive(
+            SchemaKind::Null,
+            required,
+            description.or_else(|| text(&resolved, "description")),
+        ),
+        _ => primitive(
+            SchemaKind::String,
+            required,
+            description.or_else(|| text(&resolved, "description")),
+        ),
+    }
+}
+
+pub fn object_with_fields(description: Option<String>, fields: BTreeMap<String, Schema>) -> Schema {
+    Schema {
+        kind: SchemaKind::Object,
+        description,
+        required: true,
+        nullable: false,
+        default_value: None,
+        fields,
+        items: None,
+        enum_values: Vec::new(),
+        variants: Vec::new(),
+    }
+}
+
+fn object_schema(value: &Value, required: bool, description: Option<String>) -> Schema {
+    let required_fields = value
+        .get("required")
+        .and_then(Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(Value::as_str)
+                .collect::<std::collections::BTreeSet<_>>()
+        })
+        .unwrap_or_default();
+    let mut fields = BTreeMap::new();
+
+    if let Some(properties) = value.get("properties").and_then(Value::as_object) {
+        for (name, schema) in properties {
+            fields.insert(
+                name.clone(),
+                schema_from_openapi(
+                    Some(schema),
+                    required_fields.contains(name.as_str()),
+                    text(schema, "description"),
+                ),
+            );
+        }
+    }
+
+    Schema {
+        kind: SchemaKind::Object,
+        description: description.or_else(|| text(value, "description")),
+        required,
+        nullable: nullable(value),
+        default_value: value.get("default").cloned(),
+        fields,
+        items: None,
+        enum_values: Vec::new(),
+        variants: Vec::new(),
+    }
+}
+
+fn primitive(kind: SchemaKind, required: bool, description: Option<String>) -> Schema {
+    Schema {
+        kind,
+        description,
+        required,
+        nullable: false,
+        default_value: None,
+        fields: BTreeMap::new(),
+        items: None,
+        enum_values: Vec::new(),
+        variants: Vec::new(),
+    }
+}
+
+fn type_name(value: &Value) -> Option<&str> {
+    match value.get("type") {
+        Some(Value::String(value)) => Some(value.as_str()),
+        Some(Value::Array(values)) => values.iter().find_map(Value::as_str),
+        _ if value.get("properties").is_some() => Some("object"),
+        _ if value.get("items").is_some() => Some("array"),
+        _ => None,
+    }
+}
+
+fn nullable(value: &Value) -> bool {
+    value
+        .get("nullable")
+        .and_then(Value::as_bool)
+        .unwrap_or(false)
+}
+
+fn text(value: &Value, key: &str) -> Option<String> {
+    value
+        .get(key)
+        .and_then(Value::as_str)
+        .map(ToOwned::to_owned)
+}
+
+fn collapse_composition(value: &Value) -> Value {
+    for key in ["allOf", "oneOf", "anyOf"] {
+        if let Some(items) = value.get(key).and_then(Value::as_array)
+            && let Some(first) = items.first()
+        {
+            return first.clone();
+        }
+    }
+    value.clone()
+}

crates/crank-import/src/rest/swagger2.rs

@@ -0,0 +1,234 @@
+use crank_core::HttpMethod;
+use serde_json::Value;
+
+use crate::rest::{
+    model::{RestImportDocument, RestImportOperation, RestImportParameter, RestParameterLocation},
+    normalize::{ImportParseError, resolve_local_ref},
+    recommendations::{document_finding, operation_finding},
+};
+
+pub fn parse_document(root: &Value) -> Result<RestImportDocument, ImportParseError> {
+    let title = root
+        .pointer("/info/title")
+        .and_then(Value::as_str)
+        .unwrap_or("Imported API")
+        .to_owned();
+    let servers = swagger_servers(root);
+    let mut findings = Vec::new();
+    if servers.is_empty() {
+        findings.push(document_finding(
+            "missing_servers",
+            "В Swagger 2.0 документе не указаны host/schemes, base URL нужно будет выбрать вручную.",
+        ));
+    }
+
+    let mut operations = Vec::new();
+    let paths = root
+        .get("paths")
+        .and_then(Value::as_object)
+        .ok_or(ImportParseError::UnsupportedDocument)?;
+
+    for (path, path_item) in paths {
+        let path_parameters = parameters(root, path_item.get("parameters"));
+        for method_name in ["get", "post", "put", "patch", "delete"] {
+            let Some(operation_value) = path_item.get(method_name) else {
+                continue;
+            };
+            let Some(method) = method_from_lower(method_name) else {
+                continue;
+            };
+            let mut operation_parameters = path_parameters.clone();
+            operation_parameters.extend(parameters(root, operation_value.get("parameters")));
+            let request_body_schema = operation_parameters
+                .iter()
+                .find(|parameter| parameter.name == "body")
+                .and_then(|parameter| parameter.schema.clone());
+            let operation_parameters = operation_parameters
+                .into_iter()
+                .filter(|parameter| parameter.name != "body")
+                .collect::<Vec<_>>();
+
+            operations.push(RestImportOperation {
+                key: format!("{} {}", method_name.to_uppercase(), path),
+                method,
+                path: path.clone(),
+                operation_id: operation_value
+                    .get("operationId")
+                    .and_then(Value::as_str)
+                    .map(ToOwned::to_owned),
+                summary: operation_value
+                    .get("summary")
+                    .and_then(Value::as_str)
+                    .map(ToOwned::to_owned),
+                description: operation_value
+                    .get("description")
+                    .and_then(Value::as_str)
+                    .map(ToOwned::to_owned),
+                tags: operation_value
+                    .get("tags")
+                    .and_then(Value::as_array)
+                    .map(|items| {
+                        items
+                            .iter()
+                            .filter_map(Value::as_str)
+                            .map(ToOwned::to_owned)
+                            .collect()
+                    })
+                    .unwrap_or_default(),
+                parameters: operation_parameters,
+                request_body_schema,
+                response_schema: response_schema(root, operation_value),
+                servers: Vec::new(),
+                findings: swagger_operation_findings(path, operation_value),
+            });
+        }
+    }
+
+    Ok(RestImportDocument {
+        format: "swagger".to_owned(),
+        version: Some("2.0".to_owned()),
+        title,
+        servers,
+        operations,
+        findings,
+    })
+}
+
+fn swagger_servers(root: &Value) -> Vec<String> {
+    let Some(host) = root.get("host").and_then(Value::as_str) else {
+        return Vec::new();
+    };
+    let base_path = root.get("basePath").and_then(Value::as_str).unwrap_or("");
+    let schemes = root
+        .get("schemes")
+        .and_then(Value::as_array)
+        .map(|items| items.iter().filter_map(Value::as_str).collect::<Vec<_>>())
+        .filter(|items| !items.is_empty())
+        .unwrap_or_else(|| vec!["https"]);
+
+    schemes
+        .into_iter()
+        .map(|scheme| {
+            format!("{scheme}://{host}{base_path}")
+                .trim_end_matches('/')
+                .to_owned()
+        })
+        .collect()
+}
+
+fn parameters(root: &Value, value: Option<&Value>) -> Vec<RestImportParameter> {
+    value
+        .and_then(Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(|item| {
+                    let item = resolve_local_ref(root, item, 0);
+                    let raw_location = item.get("in").and_then(Value::as_str)?;
+                    if raw_location == "body" {
+                        return Some(RestImportParameter {
+                            name: "body".to_owned(),
+                            location: RestParameterLocation::Query,
+                            required: item
+                                .get("required")
+                                .and_then(Value::as_bool)
+                                .unwrap_or(false),
+                            description: item
+                                .get("description")
+                                .and_then(Value::as_str)
+                                .map(ToOwned::to_owned),
+                            schema: item
+                                .get("schema")
+                                .map(|schema| resolve_local_ref(root, schema, 0)),
+                        });
+                    }
+                    let location = match raw_location {
+                        "path" => RestParameterLocation::Path,
+                        "query" => RestParameterLocation::Query,
+                        "header" => RestParameterLocation::Header,
+                        _ => return None,
+                    };
+                    Some(RestImportParameter {
+                        name: item.get("name").and_then(Value::as_str)?.to_owned(),
+                        location,
+                        required: item
+                            .get("required")
+                            .and_then(Value::as_bool)
+                            .unwrap_or(false)
+                            || location == RestParameterLocation::Path,
+                        description: item
+                            .get("description")
+                            .and_then(Value::as_str)
+                            .map(ToOwned::to_owned),
+                        schema: swagger_parameter_schema(root, &item),
+                    })
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn swagger_parameter_schema(root: &Value, parameter: &Value) -> Option<Value> {
+    if let Some(schema) = parameter.get("schema") {
+        return Some(resolve_local_ref(root, schema, 0));
+    }
+    let mut schema = serde_json::Map::new();
+    for key in ["type", "format", "items", "enum", "default", "description"] {
+        if let Some(value) = parameter.get(key) {
+            schema.insert(key.to_owned(), resolve_local_ref(root, value, 0));
+        }
+    }
+    if schema.is_empty() {
+        None
+    } else {
+        Some(Value::Object(schema))
+    }
+}
+
+fn response_schema(root: &Value, operation: &Value) -> Option<Value> {
+    let responses = operation.get("responses")?.as_object()?;
+    for code in ["200", "201", "202", "default"] {
+        let Some(response) = responses.get(code) else {
+            continue;
+        };
+        let response = resolve_local_ref(root, response, 0);
+        if let Some(schema) = response.get("schema") {
+            return Some(resolve_local_ref(root, schema, 0));
+        }
+    }
+    None
+}
+
+fn swagger_operation_findings(
+    path: &str,
+    operation: &Value,
+) -> Vec<crate::rest::model::ImportFinding> {
+    let mut findings = Vec::new();
+    if operation
+        .get("consumes")
+        .and_then(Value::as_array)
+        .is_some_and(|items| {
+            !items
+                .iter()
+                .any(|item| item.as_str().is_some_and(|value| value.contains("json")))
+        })
+    {
+        findings.push(operation_finding(
+            path,
+            "unsupported_consumes",
+            "Метод использует content type без JSON. Проверьте настройки тела запроса после импорта.",
+        ));
+    }
+    findings
+}
+
+fn method_from_lower(value: &str) -> Option<HttpMethod> {
+    match value {
+        "get" => Some(HttpMethod::Get),
+        "post" => Some(HttpMethod::Post),
+        "put" => Some(HttpMethod::Put),
+        "patch" => Some(HttpMethod::Patch),
+        "delete" => Some(HttpMethod::Delete),
+        _ => None,
+    }
+}

crates/crank-import/tests/unit.rs

@@ -0,0 +1,243 @@
+mod unit {
+    use crank_core::HttpMethod;
+    use crank_import::rest::preview_document;
+
+    const OPENAPI3: &str = r#"
+openapi: 3.0.3
+info:
+  title: Frankfurter API
+servers:
+  - url: https://api.frankfurter.dev
+paths:
+  /v2/latest:
+    get:
+      operationId: getLatestRates
+      summary: Получить последние курсы
+      description: Возвращает последние курсы валют для базовой валюты.
+      tags: [currency]
+      parameters:
+        - name: base
+          in: query
+          required: true
+          schema:
+            type: string
+        - name: symbols
+          in: query
+          schema:
+            type: string
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                required: [amount, base]
+                properties:
+                  amount:
+                    type: number
+                  base:
+                    type: string
+"#;
+
+    const SWAGGER2: &str = r#"
+swagger: "2.0"
+info:
+  title: Pet API
+host: petstore.example.com
+basePath: /api
+schemes: [https]
+paths:
+  /pets/{id}:
+    get:
+      operationId: getPet
+      summary: Получить питомца
+      tags: [pets]
+      parameters:
+        - name: id
+          in: path
+          required: true
+          type: string
+      responses:
+        '200':
+          description: OK
+          schema:
+            $ref: '#/definitions/Pet'
+definitions:
+  Pet:
+    type: object
+    required: [id, name]
+    properties:
+      id:
+        type: string
+      name:
+        type: string
+"#;
+
+    #[test]
+    fn previews_openapi3_rest_operations_grouped_by_tag() {
+        let preview = preview_document(OPENAPI3).unwrap();
+
+        assert_eq!(preview.source.format, "openapi");
+        assert_eq!(preview.source.servers, vec!["https://api.frankfurter.dev"]);
+        assert_eq!(preview.groups.len(), 1);
+        assert_eq!(preview.groups[0].key, "currency");
+        let operation = &preview.groups[0].operations[0];
+        assert_eq!(operation.method, HttpMethod::Get);
+        assert_eq!(operation.suggested_name, "get_latest_rates");
+        assert_eq!(operation.input_fields, 2);
+        assert_eq!(operation.output_fields, 2);
+        assert_eq!(operation.draft.target.path_template, "/v2/latest");
+        assert_eq!(operation.draft.input_mapping.rules.len(), 2);
+    }
+
+    #[test]
+    fn previews_swagger2_and_resolves_definitions() {
+        let preview = preview_document(SWAGGER2).unwrap();
+
+        assert_eq!(preview.source.format, "swagger");
+        assert_eq!(
+            preview.source.servers,
+            vec!["https://petstore.example.com/api"]
+        );
+        let operation = &preview.groups[0].operations[0];
+        assert_eq!(operation.suggested_name, "get_pet");
+        assert_eq!(operation.input_fields, 1);
+        assert_eq!(operation.output_fields, 2);
+        assert_eq!(operation.draft.target.path_template, "/pets/{id}");
+        assert_eq!(
+            operation.draft.input_mapping.rules[0].target,
+            "$.request.path.id"
+        );
+    }
+
+    #[test]
+    fn reports_missing_descriptions_as_recommendations() {
+        let document = r#"
+openapi: 3.0.3
+info: { title: Minimal API }
+paths:
+  /items:
+    get:
+      responses:
+        '204': { description: Empty }
+"#;
+
+        let preview = preview_document(document).unwrap();
+        let operation = &preview.groups[0].operations[0];
+        let codes = operation
+            .findings
+            .iter()
+            .map(|finding| finding.code.as_str())
+            .collect::<Vec<_>>();
+
+        assert!(codes.contains(&"missing_operation_id"));
+        assert!(codes.contains(&"missing_summary"));
+        assert!(codes.contains(&"missing_description"));
+        assert!(codes.contains(&"missing_response_schema"));
+    }
+
+    #[test]
+    fn expands_json_request_body_object_into_tool_inputs() {
+        let document = r#"
+openapi: 3.0.3
+info: { title: CRM API }
+servers:
+  - url: https://crm.example.test
+paths:
+  /leads:
+    post:
+      operationId: createLead
+      summary: Создать лид
+      description: Создает лид в CRM.
+      tags: [crm]
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [email]
+              properties:
+                email: { type: string }
+                name: { type: string }
+      responses:
+        '201':
+          description: Created
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  id: { type: string }
+"#;
+
+        let preview = preview_document(document).unwrap();
+        let operation = &preview.groups[0].operations[0];
+        let input_fields = &operation.draft.input_schema.fields;
+        let targets = operation
+            .draft
+            .input_mapping
+            .rules
+            .iter()
+            .map(|rule| rule.target.as_str())
+            .collect::<Vec<_>>();
+
+        assert!(input_fields.contains_key("email"));
+        assert!(input_fields.contains_key("name"));
+        assert!(targets.contains(&"$.request.body.email"));
+        assert!(targets.contains(&"$.request.body.name"));
+    }
+
+    #[test]
+    fn reports_tool_quality_recommendations_for_imported_operations() {
+        let document = r#"
+openapi: 3.0.3
+info: { title: Wide API }
+paths:
+  /items:
+    get:
+      operationId: getItems
+      summary: Get items
+      description: Get items.
+      parameters:
+        - name: page
+          in: query
+          schema: { type: integer }
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  field01: { type: string }
+                  field02: { type: string }
+                  field03: { type: string }
+                  field04: { type: string }
+                  field05: { type: string }
+                  field06: { type: string }
+                  field07: { type: string }
+                  field08: { type: string }
+                  field09: { type: string }
+                  field10: { type: string }
+                  field11: { type: string }
+                  field12: { type: string }
+                  field13: { type: string }
+"#;
+
+        let preview = preview_document(document).unwrap();
+        let operation = &preview.groups[0].operations[0];
+        let codes = operation
+            .findings
+            .iter()
+            .map(|finding| finding.code.as_str())
+            .collect::<Vec<_>>();
+
+        assert!(codes.contains(&"parameter_descriptions_missing"));
+        assert!(codes.contains(&"weak_tool_description"));
+        assert!(codes.contains(&"weak_tool_name"));
+        assert!(codes.contains(&"too_many_output_fields"));
+    }
+}

crates/crank-registry/src/error.rs

@@ -72,6 +72,8 @@ pub enum RegistryError {
     AuthProfileNotFound { auth_profile_id: String },
     #[error("yaml import job {job_id} was not found")]
     YamlImportJobNotFound { job_id: String },
+    #[error("import job {job_id} was not found")]
+    ImportJobNotFound { job_id: String },
     #[error("unsupported enum representation for field {field}")]
     InvalidEnumRepresentation { field: &'static str },
     #[error("invalid numeric value for field {field}: {value}")]

crates/crank-registry/src/lib.rs

@@ -9,7 +9,8 @@ pub use ext::{ExtensionMigration, RegistryExtension, apply_extension_migrations}
 
 pub mod records {
     pub use crate::model::{
-        AgentSummary, AgentVersionRecord, AuthUserRecord, DescriptorKind, DescriptorMetadata,
+        AgentSummary, AgentVersionRecord, ApprovalRequestRecord, AuthUserRecord, DescriptorKind,
+        DescriptorMetadata, ImportJob, ImportJobId, ImportJobKind, ImportJobStatus,
         InvitationRecord, InvocationLogRecord, MembershipRecord, OperationAgentRef,
         OperationSampleMetadata, OperationSummary, OperationUsageSummary, OperationVersionRecord,
         Page, PlatformApiKeyRecord, PublishedAgentTool, RegistryOperation, SampleKind,
@@ -22,13 +23,15 @@ pub mod records {
 
 pub mod requests {
     pub use crate::model::{
-        CreateAgentDraftVersionRequest, CreateAgentRequest, CreateInvitationRequest,
-        CreateInvocationLogRequest, CreatePlatformApiKeyRequest, CreateSecretRequest,
-        CreateVersionRequest, CreateWorkspaceRequest, CreateYamlImportJobRequest,
-        ListInvocationLogsQuery, PublishAgentRequest, PublishRequest, RotateSecretRequest,
-        SaveAgentBindingsRequest, SaveAuthProfileRequest, SaveDescriptorMetadataRequest,
-        SaveSampleMetadataRequest, SaveWorkspaceUpstreamRequest, UpdateWorkspaceRequest,
-        UsageQuery,
+        CreateAgentDraftVersionRequest, CreateAgentRequest, CreateApprovalRequest,
+        CreateImportJobRequest, CreateInvitationRequest, CreateInvocationLogRequest,
+        CreatePlatformApiKeyRequest, CreateSecretRequest, CreateVersionRequest,
+        CreateWorkspaceRequest, CreateYamlImportJobRequest, DecideApprovalRequest,
+        ExpireApprovalRequest, FinishApprovalRequest, FinishImportJobRequest,
+        ListApprovalRequestsQuery, ListInvocationLogsQuery, PublishAgentRequest, PublishRequest,
+        RotateSecretRequest, SaveAgentBindingsRequest, SaveAuthProfileRequest,
+        SaveDescriptorMetadataRequest, SaveSampleMetadataRequest, SaveWorkspaceUpstreamRequest,
+        UpdateWorkspaceRequest, UsageQuery,
     };
 }
 
@@ -38,11 +41,14 @@ pub mod infrastructure {
 }
 
 pub use model::{
-    AgentSummary, AgentVersionRecord, AuthUserRecord, CreateAgentDraftVersionRequest,
-    CreateAgentRequest, CreateInvitationRequest, CreateInvocationLogRequest,
+    AgentSummary, AgentVersionRecord, ApprovalRequestRecord, AuthUserRecord,
+    CreateAgentDraftVersionRequest, CreateAgentRequest, CreateApprovalRequest,
+    CreateImportJobRequest, CreateInvitationRequest, CreateInvocationLogRequest,
     CreatePlatformApiKeyRequest, CreateSecretRequest, CreateVersionRequest, CreateWorkspaceRequest,
-    CreateYamlImportJobRequest, DescriptorKind, DescriptorMetadata, InvitationRecord,
-    InvocationLogRecord, ListInvocationLogsQuery, MembershipRecord, OperationAgentRef,
+    CreateYamlImportJobRequest, DecideApprovalRequest, DescriptorKind, DescriptorMetadata,
+    ExpireApprovalRequest, FinishApprovalRequest, FinishImportJobRequest, ImportJob, ImportJobId,
+    ImportJobKind, ImportJobStatus, InvitationRecord, InvocationLogRecord,
+    ListApprovalRequestsQuery, ListInvocationLogsQuery, MembershipRecord, OperationAgentRef,
     OperationSampleMetadata, OperationSummary, OperationUsageSummary, OperationVersionRecord, Page,
     PlatformApiKeyRecord, PublishAgentRequest, PublishRequest, PublishedAgentTool,
     RegistryOperation, RotateSecretRequest, SampleKind, SaveAgentBindingsRequest,

crates/crank-registry/src/migrations.rs

@@ -148,11 +148,14 @@ pub async fn apply_postgres(pool: &PgPool) -> Result<(), sqlx::Error> {
             name text not null,
             prefix text not null,
             secret_hash text not null,
+            key_kind text not null default 'mcp_client',
             scopes_json jsonb not null,
             status text not null,
             created_at timestamptz not null,
             last_used_at timestamptz null,
-            revoked_at timestamptz null
+            revoked_at timestamptz null,
+            expires_at timestamptz null,
+            allowed_origins_json jsonb not null default '[]'::jsonb
         )",
     )
     .execute(pool)
@@ -166,6 +169,19 @@ pub async fn apply_postgres(pool: &PgPool) -> Result<(), sqlx::Error> {
     query("alter table platform_api_keys add column if not exists agent_id text null")
         .execute(pool)
         .await?;
+    query(
+        "alter table platform_api_keys add column if not exists key_kind text not null default 'mcp_client'",
+    )
+    .execute(pool)
+    .await?;
+    query("alter table platform_api_keys add column if not exists expires_at timestamptz null")
+        .execute(pool)
+        .await?;
+    query(
+        "alter table platform_api_keys add column if not exists allowed_origins_json jsonb not null default '[]'::jsonb",
+    )
+    .execute(pool)
+    .await?;
 
     query(
         "insert into workspaces (
@@ -451,6 +467,25 @@ pub async fn apply_postgres(pool: &PgPool) -> Result<(), sqlx::Error> {
     .execute(pool)
     .await?;
 
+    query(
+        "create table if not exists import_jobs (
+            id text primary key,
+            workspace_id text not null references workspaces(id) on delete cascade,
+            kind text not null,
+            source_format text not null,
+            source_version text null,
+            status text not null,
+            preview_payload jsonb not null,
+            created_operation_ids jsonb not null default '[]'::jsonb,
+            error_text text null,
+            created_at timestamptz not null,
+            expires_at timestamptz not null,
+            finished_at timestamptz null
+        )",
+    )
+    .execute(pool)
+    .await?;
+
     query(
         "create table if not exists agents (
             id text primary key,
@@ -524,6 +559,40 @@ pub async fn apply_postgres(pool: &PgPool) -> Result<(), sqlx::Error> {
     .execute(pool)
     .await?;
 
+    query(
+        "create table if not exists approval_requests (
+            id text primary key,
+            workspace_id text not null references workspaces(id) on delete cascade,
+            agent_id text not null references agents(id) on delete cascade,
+            operation_id text not null references operations(id) on delete cascade,
+            operation_version integer not null,
+            status text not null,
+            risk_level text not null,
+            request_payload_json jsonb not null,
+            response_payload_json jsonb null,
+            created_at timestamptz not null,
+            expires_at timestamptz not null,
+            decided_at timestamptz null,
+            decided_by_key_id text null references platform_api_keys(id) on delete set null,
+            decision_note text null
+        )",
+    )
+    .execute(pool)
+    .await?;
+
+    query("alter table approval_requests drop column if exists confirmation_title")
+        .execute(pool)
+        .await?;
+    query("alter table approval_requests drop column if exists confirmation_body")
+        .execute(pool)
+        .await?;
+    query(
+        "create index if not exists approval_requests_agent_status_idx
+         on approval_requests(workspace_id, agent_id, status, expires_at)",
+    )
+    .execute(pool)
+    .await?;
+
     query(
         "create table if not exists invocation_logs (
             id text primary key,

crates/crank-registry/src/model.rs

@@ -1,9 +1,10 @@
 use crank_core::{
-    Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, AuthProfile, DescriptorId,
-    ExportMode, InvitationToken, InvocationLevel, InvocationLog, InvocationSource, MembershipRole,
-    Operation, OperationId, OperationSecurityLevel, OperationStatus, PlatformApiKey, Protocol,
-    SampleId, Secret, SecretId, SecretVersion, UsagePeriod, UsageRollup, User, UserSessionId,
-    Workspace, WorkspaceId,
+    Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ApprovalRequest,
+    ApprovalRequestId, ApprovalRequestStatus, AuthProfile, DescriptorId, ExportMode,
+    InvitationToken, InvocationLevel, InvocationLog, InvocationSource, MembershipRole, Operation,
+    OperationId, OperationSecurityLevel, OperationStatus, PlatformApiKey, PlatformApiKeyId,
+    Protocol, SampleId, Secret, SecretId, SecretVersion, UsagePeriod, UsageRollup, User,
+    UserSessionId, Workspace, WorkspaceId,
 };
 use crank_mapping::MappingSet;
 use crank_schema::Schema;
@@ -41,6 +42,7 @@ macro_rules! define_registry_id {
 }
 
 define_registry_id!(YamlImportJobId);
+define_registry_id!(ImportJobId);
 define_registry_id!(WorkspaceUpstreamId);
 
 pub type RegistryOperation = Operation<Schema, MappingSet>;
@@ -94,6 +96,11 @@ pub struct PlatformApiKeyRecord {
     pub api_key: PlatformApiKey,
 }
 
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApprovalRequestRecord {
+    pub approval: ApprovalRequest,
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct SecretRecord {
     pub secret: Secret,
@@ -326,6 +333,61 @@ pub struct YamlImportJobCompletion {
     pub finished_at: OffsetDateTime,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ImportJobStatus {
+    Pending,
+    Completed,
+    Failed,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ImportJobKind {
+    OpenApi,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportJob {
+    pub id: ImportJobId,
+    pub workspace_id: WorkspaceId,
+    pub kind: ImportJobKind,
+    pub source_format: String,
+    pub source_version: Option<String>,
+    pub status: ImportJobStatus,
+    pub preview_payload: Value,
+    pub created_operation_ids: Value,
+    pub error_text: Option<String>,
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339")]
+    pub expires_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub finished_at: Option<OffsetDateTime>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct CreateImportJobRequest<'a> {
+    pub id: &'a ImportJobId,
+    pub workspace_id: &'a WorkspaceId,
+    pub kind: ImportJobKind,
+    pub source_format: &'a str,
+    pub source_version: Option<&'a str>,
+    pub status: ImportJobStatus,
+    pub preview_payload: &'a Value,
+    pub created_at: &'a OffsetDateTime,
+    pub expires_at: &'a OffsetDateTime,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct FinishImportJobRequest<'a> {
+    pub id: &'a ImportJobId,
+    pub status: ImportJobStatus,
+    pub created_operation_ids: &'a Value,
+    pub error_text: Option<&'a str>,
+    pub finished_at: &'a OffsetDateTime,
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct CreateInvocationLogRequest<'a> {
     pub log: &'a InvocationLog,
@@ -457,6 +519,48 @@ pub struct CreatePlatformApiKeyRequest<'a> {
     pub secret_hash: &'a str,
 }
 
+#[derive(Clone, Debug)]
+pub struct CreateApprovalRequest<'a> {
+    pub approval: &'a ApprovalRequest,
+}
+
+#[derive(Clone, Debug)]
+pub struct ListApprovalRequestsQuery<'a> {
+    pub workspace_id: &'a WorkspaceId,
+    pub status: Option<ApprovalRequestStatus>,
+    pub limit: u32,
+}
+
+#[derive(Clone, Debug)]
+pub struct DecideApprovalRequest<'a> {
+    pub workspace_id: &'a WorkspaceId,
+    pub agent_id: &'a AgentId,
+    pub approval_id: &'a ApprovalRequestId,
+    pub status: ApprovalRequestStatus,
+    pub decided_at: OffsetDateTime,
+    pub decided_by_key_id: &'a PlatformApiKeyId,
+    pub response_payload: Option<Value>,
+    pub decision_note: Option<&'a str>,
+}
+
+#[derive(Clone, Debug)]
+pub struct FinishApprovalRequest<'a> {
+    pub workspace_id: &'a WorkspaceId,
+    pub agent_id: &'a AgentId,
+    pub approval_id: &'a ApprovalRequestId,
+    pub status: ApprovalRequestStatus,
+    pub response_payload: Option<Value>,
+    pub decision_note: Option<&'a str>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ExpireApprovalRequest<'a> {
+    pub workspace_id: &'a WorkspaceId,
+    pub agent_id: &'a AgentId,
+    pub approval_id: &'a ApprovalRequestId,
+    pub expired_at: OffsetDateTime,
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct CreateSecretRequest<'a> {
     pub secret: &'a Secret,

crates/crank-registry/src/postgres/api_key.rs

@@ -11,12 +11,15 @@ impl PostgresRegistry {
                 id,
                 workspace_id,
                 agent_id,
+                key_kind,
                 name,
                 prefix,
                 scopes_json,
                 status,
                 created_at,
-                last_used_at
+                last_used_at,
+                expires_at,
+                allowed_origins_json
              from platform_api_keys
              where workspace_id = $1
                and agent_id = $2
@@ -34,12 +37,20 @@ impl PostgresRegistry {
                         id: PlatformApiKeyId::new(row.get::<String, _>("id")),
                         workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
                         agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                        key_kind: deserialize_enum_text(
+                            &row.get::<String, _>("key_kind"),
+                            "key_kind",
+                        )?,
                         name: row.get("name"),
                         prefix: row.get("prefix"),
                         scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
                         status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
                         created_at: row.get("created_at"),
                         last_used_at: row.get("last_used_at"),
+                        expires_at: row.get("expires_at"),
+                        allowed_origins: deserialize_json_value(
+                            row.get::<Value, _>("allowed_origins_json"),
+                        )?,
                     },
                 })
             })
@@ -55,12 +66,15 @@ impl PostgresRegistry {
                 id,
                 workspace_id,
                 agent_id,
+                key_kind,
                 name,
                 prefix,
                 scopes_json,
                 status,
                 created_at,
-                last_used_at
+                last_used_at,
+                expires_at,
+                allowed_origins_json
              from platform_api_keys
              where workspace_id = $1
              order by created_at desc",
@@ -76,12 +90,20 @@ impl PostgresRegistry {
                         id: PlatformApiKeyId::new(row.get::<String, _>("id")),
                         workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
                         agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                        key_kind: deserialize_enum_text(
+                            &row.get::<String, _>("key_kind"),
+                            "key_kind",
+                        )?,
                         name: row.get("name"),
                         prefix: row.get("prefix"),
                         scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
                         status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
                         created_at: row.get("created_at"),
                         last_used_at: row.get("last_used_at"),
+                        expires_at: row.get("expires_at"),
+                        allowed_origins: deserialize_json_value(
+                            row.get::<Value, _>("allowed_origins_json"),
+                        )?,
                     },
                 })
             })
@@ -99,19 +121,24 @@ impl PostgresRegistry {
                 k.id,
                 k.workspace_id,
                 k.agent_id,
+                k.key_kind,
                 k.name,
                 k.prefix,
                 k.scopes_json,
                 k.status,
                 k.created_at,
-                k.last_used_at
+                k.last_used_at,
+                k.expires_at,
+                k.allowed_origins_json
              from platform_api_keys k
              join workspaces w on w.id = k.workspace_id
              join agents a on a.id = k.agent_id
              where w.slug = $1
                and a.slug = $2
                and k.secret_hash = $3
+               and k.key_kind = 'mcp_client'
                and k.status = 'active'
+               and (k.expires_at is null or k.expires_at > now())
              limit 1",
         )
         .bind(workspace_slug)
@@ -126,12 +153,77 @@ impl PostgresRegistry {
                     id: PlatformApiKeyId::new(row.get::<String, _>("id")),
                     workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
                     agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                    key_kind: deserialize_enum_text(&row.get::<String, _>("key_kind"), "key_kind")?,
                     name: row.get("name"),
                     prefix: row.get("prefix"),
                     scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
                     status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
                     created_at: row.get("created_at"),
                     last_used_at: row.get("last_used_at"),
+                    expires_at: row.get("expires_at"),
+                    allowed_origins: deserialize_json_value(
+                        row.get::<Value, _>("allowed_origins_json"),
+                    )?,
+                },
+            })
+        })
+        .transpose()
+    }
+
+    pub async fn get_approval_api_key_by_secret_for_agent_slug(
+        &self,
+        workspace_slug: &str,
+        agent_slug: &str,
+        secret_hash: &str,
+    ) -> Result<Option<PlatformApiKeyRecord>, RegistryError> {
+        let row = sqlx::query(
+            "select
+                k.id,
+                k.workspace_id,
+                k.agent_id,
+                k.key_kind,
+                k.name,
+                k.prefix,
+                k.scopes_json,
+                k.status,
+                k.created_at,
+                k.last_used_at,
+                k.expires_at,
+                k.allowed_origins_json
+             from platform_api_keys k
+             join workspaces w on w.id = k.workspace_id
+             join agents a on a.id = k.agent_id
+             where w.slug = $1
+               and a.slug = $2
+               and k.secret_hash = $3
+               and k.key_kind = 'approval'
+               and k.status = 'active'
+               and (k.expires_at is null or k.expires_at > now())
+             limit 1",
+        )
+        .bind(workspace_slug)
+        .bind(agent_slug)
+        .bind(secret_hash)
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(|row| {
+            Ok(PlatformApiKeyRecord {
+                api_key: PlatformApiKey {
+                    id: PlatformApiKeyId::new(row.get::<String, _>("id")),
+                    workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
+                    agent_id: row.get::<Option<String>, _>("agent_id").map(AgentId::new),
+                    key_kind: deserialize_enum_text(&row.get::<String, _>("key_kind"), "key_kind")?,
+                    name: row.get("name"),
+                    prefix: row.get("prefix"),
+                    scopes: deserialize_json_value(row.get::<Value, _>("scopes_json"))?,
+                    status: deserialize_enum_text(&row.get::<String, _>("status"), "status")?,
+                    created_at: row.get("created_at"),
+                    last_used_at: row.get("last_used_at"),
+                    expires_at: row.get("expires_at"),
+                    allowed_origins: deserialize_json_value(
+                        row.get::<Value, _>("allowed_origins_json"),
+                    )?,
                 },
             })
         })
@@ -150,13 +242,16 @@ impl PostgresRegistry {
                 name,
                 prefix,
                 secret_hash,
+                key_kind,
                 scopes_json,
                 status,
                 created_at,
                 last_used_at,
-                revoked_at
+                revoked_at,
+                expires_at,
+                allowed_origins_json
              ) values (
-                $1, $2, $3, $4, $5, $6, $7, $8, $9::timestamptz, $10::timestamptz, $11::timestamptz
+                $1, $2, $3, $4, $5, $6, $7, $8, $9, $10::timestamptz, $11::timestamptz, $12::timestamptz, $13::timestamptz, $14
              )",
         )
         .bind(request.api_key.id.as_str())
@@ -165,11 +260,14 @@ impl PostgresRegistry {
         .bind(&request.api_key.name)
         .bind(&request.api_key.prefix)
         .bind(request.secret_hash)
+        .bind(serialize_enum_text(&request.api_key.key_kind, "key_kind")?)
         .bind(Json(serialize_json_value(&request.api_key.scopes)?))
         .bind(serialize_enum_text(&request.api_key.status, "status")?)
         .bind(request.api_key.created_at)
         .bind(request.api_key.last_used_at)
         .bind(Option::<&str>::None)
+        .bind(request.api_key.expires_at)
+        .bind(Json(serialize_json_value(&request.api_key.allowed_origins)?))
         .execute(&self.pool)
         .await;
 

crates/crank-registry/src/postgres/approval.rs

@@ -0,0 +1,358 @@
+use super::*;
+
+impl PostgresRegistry {
+    pub async fn create_approval_request(
+        &self,
+        request: CreateApprovalRequest<'_>,
+    ) -> Result<(), RegistryError> {
+        sqlx::query(
+            "insert into approval_requests (
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note
+            ) values (
+                $1, $2, $3, $4, $5, $6, $7, $8,
+                $9, $10::timestamptz, $11::timestamptz, $12::timestamptz,
+                $13, $14
+            )",
+        )
+        .bind(request.approval.id.as_str())
+        .bind(request.approval.workspace_id.as_str())
+        .bind(request.approval.agent_id.as_str())
+        .bind(request.approval.operation_id.as_str())
+        .bind(to_db_version(request.approval.operation_version))
+        .bind(serialize_enum_text(
+            &request.approval.status,
+            "approval_status",
+        )?)
+        .bind(serialize_enum_text(
+            &request.approval.risk_level,
+            "approval_risk_level",
+        )?)
+        .bind(Json(&request.approval.request_payload))
+        .bind(request.approval.response_payload.as_ref().map(Json))
+        .bind(request.approval.created_at)
+        .bind(request.approval.expires_at)
+        .bind(request.approval.decided_at)
+        .bind(
+            request
+                .approval
+                .decided_by_key_id
+                .as_ref()
+                .map(PlatformApiKeyId::as_str),
+        )
+        .bind(request.approval.decision_note.as_deref())
+        .execute(&self.pool)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn list_pending_approval_requests_for_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+    ) -> Result<Vec<ApprovalRequestRecord>, RegistryError> {
+        let rows = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note
+             from approval_requests
+             where workspace_id = $1
+               and agent_id = $2
+               and status = 'pending'
+               and expires_at > now()
+             order by created_at asc",
+        )
+        .bind(workspace_id.as_str())
+        .bind(agent_id.as_str())
+        .fetch_all(&self.pool)
+        .await?;
+
+        rows.into_iter().map(map_approval_request_row).collect()
+    }
+
+    pub async fn get_approval_request_for_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+        approval_id: &ApprovalRequestId,
+    ) -> Result<Option<ApprovalRequestRecord>, RegistryError> {
+        let row = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note
+             from approval_requests
+             where workspace_id = $1
+               and agent_id = $2
+               and id = $3
+             limit 1",
+        )
+        .bind(workspace_id.as_str())
+        .bind(agent_id.as_str())
+        .bind(approval_id.as_str())
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(map_approval_request_row).transpose()
+    }
+
+    pub async fn list_approval_requests(
+        &self,
+        query: ListApprovalRequestsQuery<'_>,
+    ) -> Result<Vec<ApprovalRequestRecord>, RegistryError> {
+        let status = query
+            .status
+            .map(|status| serialize_enum_text(&status, "approval_status"))
+            .transpose()?;
+        let rows = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note
+             from approval_requests
+             where workspace_id = $1
+               and ($2::text is null or status = $2)
+             order by created_at desc
+             limit $3",
+        )
+        .bind(query.workspace_id.as_str())
+        .bind(status.as_deref())
+        .bind(i64::from(query.limit))
+        .fetch_all(&self.pool)
+        .await?;
+
+        rows.into_iter().map(map_approval_request_row).collect()
+    }
+
+    pub async fn get_approval_request(
+        &self,
+        workspace_id: &WorkspaceId,
+        approval_id: &ApprovalRequestId,
+    ) -> Result<Option<ApprovalRequestRecord>, RegistryError> {
+        let row = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note
+             from approval_requests
+             where workspace_id = $1
+               and id = $2
+             limit 1",
+        )
+        .bind(workspace_id.as_str())
+        .bind(approval_id.as_str())
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(map_approval_request_row).transpose()
+    }
+
+    pub async fn decide_approval_request(
+        &self,
+        request: DecideApprovalRequest<'_>,
+    ) -> Result<Option<ApprovalRequestRecord>, RegistryError> {
+        let row = sqlx::query(
+            "update approval_requests
+                set status = $1,
+                    response_payload_json = $2,
+                    decided_at = $3::timestamptz,
+                    decided_by_key_id = $4,
+                    decision_note = $5
+              where workspace_id = $6
+                and agent_id = $7
+                and id = $8
+                and status = 'pending'
+                and expires_at > $3::timestamptz
+              returning
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note",
+        )
+        .bind(serialize_enum_text(&request.status, "approval_status")?)
+        .bind(request.response_payload.as_ref().map(Json))
+        .bind(request.decided_at)
+        .bind(request.decided_by_key_id.as_str())
+        .bind(request.decision_note)
+        .bind(request.workspace_id.as_str())
+        .bind(request.agent_id.as_str())
+        .bind(request.approval_id.as_str())
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(map_approval_request_row).transpose()
+    }
+
+    pub async fn finish_approval_request(
+        &self,
+        request: FinishApprovalRequest<'_>,
+    ) -> Result<Option<ApprovalRequestRecord>, RegistryError> {
+        let row = sqlx::query(
+            "update approval_requests
+                set status = $1,
+                    response_payload_json = $2,
+                    decision_note = coalesce($3, decision_note)
+              where workspace_id = $4
+                and agent_id = $5
+                and id = $6
+                and status = 'approved'
+              returning
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note",
+        )
+        .bind(serialize_enum_text(&request.status, "approval_status")?)
+        .bind(request.response_payload.as_ref().map(Json))
+        .bind(request.decision_note)
+        .bind(request.workspace_id.as_str())
+        .bind(request.agent_id.as_str())
+        .bind(request.approval_id.as_str())
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(map_approval_request_row).transpose()
+    }
+
+    pub async fn expire_approval_request(
+        &self,
+        request: ExpireApprovalRequest<'_>,
+    ) -> Result<Option<ApprovalRequestRecord>, RegistryError> {
+        let row = sqlx::query(
+            "update approval_requests
+                set status = 'expired'
+              where workspace_id = $1
+                and agent_id = $2
+                and id = $3
+                and status = 'pending'
+                and expires_at <= $4::timestamptz
+              returning
+                id,
+                workspace_id,
+                agent_id,
+                operation_id,
+                operation_version,
+                status,
+                risk_level,
+                request_payload_json,
+                response_payload_json,
+                created_at,
+                expires_at,
+                decided_at,
+                decided_by_key_id,
+                decision_note",
+        )
+        .bind(request.workspace_id.as_str())
+        .bind(request.agent_id.as_str())
+        .bind(request.approval_id.as_str())
+        .bind(request.expired_at)
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(map_approval_request_row).transpose()
+    }
+}
+
+fn map_approval_request_row(row: PgRow) -> Result<ApprovalRequestRecord, RegistryError> {
+    Ok(ApprovalRequestRecord {
+        approval: ApprovalRequest {
+            id: ApprovalRequestId::new(row.get::<String, _>("id")),
+            workspace_id: WorkspaceId::new(row.get::<String, _>("workspace_id")),
+            agent_id: AgentId::new(row.get::<String, _>("agent_id")),
+            operation_id: OperationId::new(row.get::<String, _>("operation_id")),
+            operation_version: from_db_version(row.get("operation_version"), "operation_version")?,
+            status: deserialize_enum_text(&row.get::<String, _>("status"), "approval_status")?,
+            risk_level: deserialize_enum_text(
+                &row.get::<String, _>("risk_level"),
+                "approval_risk_level",
+            )?,
+            request_payload: row.get::<Value, _>("request_payload_json"),
+            response_payload: row.get::<Option<Value>, _>("response_payload_json"),
+            created_at: row.get("created_at"),
+            expires_at: row.get("expires_at"),
+            decided_at: row.get("decided_at"),
+            decided_by_key_id: row
+                .get::<Option<String>, _>("decided_by_key_id")
+                .map(PlatformApiKeyId::new),
+            decision_note: row.get("decision_note"),
+        },
+    })
+}

crates/crank-registry/src/postgres/connection.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use sqlx::{
-    PgPool,
+    AssertSqlSafe, PgPool,
     postgres::{PgConnectOptions, PgPoolOptions},
 };
 
@@ -58,7 +58,7 @@ impl PostgresRegistry {
             .await?;
 
         if let Some(schema) = schema {
-            sqlx::query(&format!("set search_path to {schema}"))
+            sqlx::query(AssertSqlSafe(format!("set search_path to {schema}")))
                 .execute(&pool)
                 .await?;
         }

crates/crank-registry/src/postgres/import_job.rs

@@ -0,0 +1,107 @@
+use super::*;
+
+impl PostgresRegistry {
+    pub async fn create_import_job(
+        &self,
+        request: CreateImportJobRequest<'_>,
+    ) -> Result<(), RegistryError> {
+        sqlx::query(
+            "insert into import_jobs (
+                id,
+                workspace_id,
+                kind,
+                source_format,
+                source_version,
+                status,
+                preview_payload,
+                created_operation_ids,
+                error_text,
+                created_at,
+                expires_at,
+                finished_at
+             ) values (
+                $1, $2, $3, $4, $5, $6, $7, '[]'::jsonb, null, $8::timestamptz, $9::timestamptz, null
+             )",
+        )
+        .bind(request.id.as_str())
+        .bind(request.workspace_id.as_str())
+        .bind(serialize_enum_text(&request.kind, "kind")?)
+        .bind(request.source_format)
+        .bind(request.source_version)
+        .bind(serialize_enum_text(&request.status, "status")?)
+        .bind(request.preview_payload)
+        .bind(request.created_at)
+        .bind(request.expires_at)
+        .execute(&self.pool)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn get_import_job(
+        &self,
+        workspace_id: &WorkspaceId,
+        job_id: &ImportJobId,
+    ) -> Result<Option<ImportJob>, RegistryError> {
+        let row = sqlx::query(
+            "select
+                id,
+                workspace_id,
+                kind,
+                source_format,
+                source_version,
+                status,
+                preview_payload,
+                created_operation_ids,
+                error_text,
+                created_at,
+                expires_at,
+                finished_at
+             from import_jobs
+             where id = $1 and workspace_id = $2",
+        )
+        .bind(job_id.as_str())
+        .bind(workspace_id.as_str())
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.as_ref().map(map_import_job).transpose()
+    }
+
+    pub async fn finish_import_job(
+        &self,
+        request: FinishImportJobRequest<'_>,
+    ) -> Result<(), RegistryError> {
+        let result = sqlx::query(
+            "update import_jobs
+                set status = $2,
+                    created_operation_ids = $3,
+                    error_text = $4,
+                    finished_at = $5::timestamptz
+              where id = $1",
+        )
+        .bind(request.id.as_str())
+        .bind(serialize_enum_text(&request.status, "status")?)
+        .bind(request.created_operation_ids)
+        .bind(request.error_text)
+        .bind(request.finished_at)
+        .execute(&self.pool)
+        .await?;
+
+        if result.rows_affected() == 0 {
+            return Err(RegistryError::ImportJobNotFound {
+                job_id: request.id.as_str().to_owned(),
+            });
+        }
+
+        Ok(())
+    }
+
+    pub async fn delete_expired_import_jobs(&self) -> Result<u64, RegistryError> {
+        let result = sqlx::query("delete from import_jobs where expires_at < now()")
+            .execute(&self.pool)
+            .await?;
+
+        Ok(result.rows_affected())
+    }
+}

crates/crank-registry/src/postgres/mod.rs

@@ -1,7 +1,9 @@
 mod agent;
 mod api_key;
+mod approval;
 mod auth;
 mod connection;
+mod import_job;
 mod observability;
 mod operation;
 mod operation_artifact;
@@ -12,10 +14,11 @@ mod workspace;
 mod yaml_import;
 
 use crank_core::{
-    AgentId, AgentOperationBinding, AgentStatus, AgentVersion, AuthProfile, HttpMethod,
-    InvitationId, InvitationToken, InvocationLog, InvocationLogId, MembershipRole, OperationId,
-    OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyStatus, Secret, SecretId,
-    SecretVersion, Target, UsageRollup, User, UserId, UserSessionId, Workspace, WorkspaceId,
+    AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ApprovalRequest, ApprovalRequestId,
+    AuthProfile, HttpMethod, InvitationId, InvitationToken, InvocationLog, InvocationLogId,
+    MembershipRole, OperationId, OperationStatus, PlatformApiKey, PlatformApiKeyId,
+    PlatformApiKeyStatus, Secret, SecretId, SecretVersion, Target, UsageRollup, User, UserId,
+    UserSessionId, Workspace, WorkspaceId,
 };
 use serde::{Serialize, de::DeserializeOwned};
 use serde_json::Value;
@@ -27,14 +30,17 @@ pub use pool_config::{PostgresPoolConfig, PostgresPoolConfigError};
 use crate::{
     error::RegistryError,
     model::{
-        AgentSummary, AgentVersionRecord, AuthUserRecord, CreateAgentDraftVersionRequest,
-        CreateAgentRequest, CreateInvitationRequest, CreateInvocationLogRequest,
+        AgentSummary, AgentVersionRecord, ApprovalRequestRecord, AuthUserRecord,
+        CreateAgentDraftVersionRequest, CreateAgentRequest, CreateApprovalRequest,
+        CreateImportJobRequest, CreateInvitationRequest, CreateInvocationLogRequest,
         CreatePlatformApiKeyRequest, CreateSecretRequest, CreateVersionRequest,
-        CreateWorkspaceRequest, CreateYamlImportJobRequest, DescriptorMetadata, InvitationRecord,
-        InvocationLogRecord, ListInvocationLogsQuery, MembershipRecord, OperationAgentRef,
-        OperationSampleMetadata, OperationSummary, OperationUsageSummary, OperationVersionRecord,
-        PlatformApiKeyRecord, PublishAgentRequest, PublishRequest, PublishedAgentTool,
-        RegistryOperation, RotateSecretRequest, SaveAgentBindingsRequest, SaveAuthProfileRequest,
+        CreateWorkspaceRequest, CreateYamlImportJobRequest, DecideApprovalRequest,
+        DescriptorMetadata, ExpireApprovalRequest, FinishApprovalRequest, FinishImportJobRequest,
+        ImportJob, ImportJobId, InvitationRecord, InvocationLogRecord, ListApprovalRequestsQuery,
+        ListInvocationLogsQuery, MembershipRecord, OperationAgentRef, OperationSampleMetadata,
+        OperationSummary, OperationUsageSummary, OperationVersionRecord, PlatformApiKeyRecord,
+        PublishAgentRequest, PublishRequest, PublishedAgentTool, RegistryOperation,
+        RotateSecretRequest, SaveAgentBindingsRequest, SaveAuthProfileRequest,
         SaveDescriptorMetadataRequest, SaveSampleMetadataRequest, SaveWorkspaceUpstreamRequest,
         SecretRecord, SecretVersionRecord, SessionRecord, UpdateWorkspaceRequest,
         UsageAgentBreakdown, UsageOperationBreakdown, UsageQuery, UsageRollupRecord, UsageSummary,
@@ -661,6 +667,23 @@ fn map_yaml_import_job(row: &PgRow) -> Result<YamlImportJob, RegistryError> {
     })
 }
 
+fn map_import_job(row: &PgRow) -> Result<ImportJob, RegistryError> {
+    Ok(ImportJob {
+        id: ImportJobId::new(row.try_get::<String, _>("id")?),
+        workspace_id: WorkspaceId::new(row.try_get::<String, _>("workspace_id")?),
+        kind: deserialize_enum_text(&row.try_get::<String, _>("kind")?, "kind")?,
+        source_format: row.try_get("source_format")?,
+        source_version: row.try_get("source_version")?,
+        status: deserialize_enum_text(&row.try_get::<String, _>("status")?, "status")?,
+        preview_payload: row.try_get("preview_payload")?,
+        created_operation_ids: row.try_get("created_operation_ids")?,
+        error_text: row.try_get("error_text")?,
+        created_at: row.try_get("created_at")?,
+        expires_at: row.try_get("expires_at")?,
+        finished_at: row.try_get("finished_at")?,
+    })
+}
+
 fn map_usage_operation_breakdown(row: &PgRow) -> Result<UsageOperationBreakdown, RegistryError> {
     Ok(UsageOperationBreakdown {
         operation_id: OperationId::new(row.try_get::<String, _>("operation_id")?),

crates/crank-registry/src/postgres/observability.rs

@@ -239,7 +239,7 @@ impl PostgresRegistry {
              group by 1
              order by 1 asc"
         );
-        let rows = sqlx::query(&sql)
+        let rows = sqlx::query(sqlx::AssertSqlSafe(sql))
             .bind(query.workspace_id.as_str())
             .bind(query.created_after)
             .bind(

crates/crank-registry/tests/integration/common.rs

@@ -156,6 +156,7 @@ pub(super) fn test_operation(id: &str, version: u32, status: OperationStatus) ->
             input_sample: Some(json!({ "email": format!("lead-{version}@example.com") })),
             output_sample: Some(json!({ "id": format!("lead_{version}") })),
             test_input: Some(json!({ "email": format!("test-v{version}@example.com") })),
+            import_findings: Vec::new(),
         }),
         created_at: timestamp("2026-03-25T11:58:00Z"),
         updated_at: timestamp(&format!("2026-03-25T12:{version:02}:00Z")),
@@ -244,7 +245,9 @@ impl TestDatabase {
         let schema = crank_test_support::unique_schema_name("test_registry");
 
         admin_pool
-            .execute(sqlx::query(&format!("create schema {schema}")))
+            .execute(sqlx::query(sqlx::AssertSqlSafe(format!(
+                "create schema {schema}"
+            ))))
             .await
             .unwrap();
 
@@ -266,10 +269,10 @@ impl TestDatabase {
 
     pub(super) async fn cleanup(&self) {
         self.admin_pool
-            .execute(sqlx::query(&format!(
+            .execute(sqlx::query(sqlx::AssertSqlSafe(format!(
                 "drop schema if exists {} cascade",
                 self.schema
-            )))
+            ))))
             .await
             .unwrap();
     }

crates/crank-registry/tests/integration/workspace_access.rs

@@ -5,10 +5,11 @@ use super::common::*;
 use std::collections::BTreeMap;
 
 use crank_core::{
-    AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ApiKeyHeaderAuthConfig, AuthConfig,
-    AuthKind, AuthProfile, ConfigExport, ExecutionConfig, ExportMode, GeneratedDraft,
-    GeneratedDraftStatus, HttpMethod, InvocationLog, MembershipRole, OperationId,
-    OperationSecurityLevel, OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyScope,
+    AgentId, AgentOperationBinding, AgentStatus, AgentVersion, ApiKeyHeaderAuthConfig,
+    ApprovalRequest, ApprovalRequestId, ApprovalRequestStatus, AuthConfig, AuthKind, AuthProfile,
+    ConfigExport, ExecutionConfig, ExportMode, GeneratedDraft, GeneratedDraftStatus, HttpMethod,
+    InvocationLog, MembershipRole, OperationApprovalRiskLevel, OperationId, OperationSecurityLevel,
+    OperationStatus, PlatformApiKey, PlatformApiKeyId, PlatformApiKeyKind, PlatformApiKeyScope,
     PlatformApiKeyStatus, Protocol, RestTarget, RetryPolicy, Samples, SecretId, Target,
     ToolDescription, ToolExample, User, UserId, UserSessionId, WizardState, Workspace, WorkspaceId,
 };
@@ -19,13 +20,14 @@ use sqlx::{Executor, PgPool, postgres::PgPoolOptions};
 use time::{OffsetDateTime, format_description::well_known::Rfc3339};
 
 use crank_registry::{
-    CreateAgentRequest, CreateInvocationLogRequest, CreatePlatformApiKeyRequest,
-    CreateVersionRequest, CreateWorkspaceRequest, CreateYamlImportJobRequest, DescriptorKind,
-    DescriptorMetadata, OperationSampleMetadata, PlatformApiKeyRecord, PostgresRegistry,
-    PublishAgentRequest, PublishRequest, RegistryError, RegistryOperation, SampleKind,
-    SaveAuthProfileRequest, SaveDescriptorMetadataRequest, SaveSampleMetadataRequest,
-    UpdateWorkspaceRequest, WorkspaceRecord, YamlImportJobCompletion, YamlImportJobId,
-    YamlImportJobStatus,
+    CreateAgentRequest, CreateApprovalRequest, CreateInvocationLogRequest,
+    CreatePlatformApiKeyRequest, CreateVersionRequest, CreateWorkspaceRequest,
+    CreateYamlImportJobRequest, DecideApprovalRequest, DescriptorKind, DescriptorMetadata,
+    FinishApprovalRequest, ListApprovalRequestsQuery, OperationSampleMetadata,
+    PlatformApiKeyRecord, PostgresRegistry, PublishAgentRequest, PublishRequest, RegistryError,
+    RegistryOperation, SampleKind, SaveAuthProfileRequest, SaveDescriptorMetadataRequest,
+    SaveSampleMetadataRequest, UpdateWorkspaceRequest, WorkspaceRecord, YamlImportJobCompletion,
+    YamlImportJobId, YamlImportJobStatus,
 };
 
 fn test_workspace_id() -> WorkspaceId {
@@ -372,12 +374,15 @@ async fn manages_platform_api_key_read_paths() {
         id: PlatformApiKeyId::new("key_01"),
         workspace_id: workspace.id.clone(),
         agent_id: Some(agent.id.clone()),
+        key_kind: PlatformApiKeyKind::McpClient,
         name: "Primary".to_owned(),
         prefix: "crk_live".to_owned(),
         scopes: vec![PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
         status: PlatformApiKeyStatus::Active,
         created_at: timestamp("2026-03-25T12:01:00Z"),
         last_used_at: None,
+        expires_at: None,
+        allowed_origins: Vec::new(),
     };
     let secret_hash = "secret_hash_01";
 
@@ -451,3 +456,175 @@ async fn manages_platform_api_key_read_paths() {
 
     database.cleanup().await;
 }
+
+#[tokio::test]
+async fn manages_approval_request_lifecycle() {
+    let database = TestDatabase::new().await;
+    let registry = database.registry().await;
+    let workspace_id = test_workspace_id();
+    let operation = test_operation("op_approval_01", 1, OperationStatus::Draft);
+    let agent = test_agent("agent_approval_01", AgentStatus::Draft);
+    let version = test_agent_version(&agent.id, 1, AgentStatus::Draft);
+    let approval_key = PlatformApiKey {
+        id: PlatformApiKeyId::new("key_approval_01"),
+        workspace_id: workspace_id.clone(),
+        agent_id: Some(agent.id.clone()),
+        key_kind: PlatformApiKeyKind::Approval,
+        name: "Approval key".to_owned(),
+        prefix: "crk_appr".to_owned(),
+        scopes: vec![PlatformApiKeyScope::Approve, PlatformApiKeyScope::Deny],
+        status: PlatformApiKeyStatus::Active,
+        created_at: timestamp("2026-03-25T12:00:00Z"),
+        last_used_at: None,
+        expires_at: None,
+        allowed_origins: Vec::new(),
+    };
+    let approval = ApprovalRequest {
+        id: ApprovalRequestId::new("approval_01"),
+        workspace_id: workspace_id.clone(),
+        agent_id: agent.id.clone(),
+        operation_id: operation.id.clone(),
+        operation_version: 1,
+        status: ApprovalRequestStatus::Pending,
+        risk_level: OperationApprovalRiskLevel::Dangerous,
+        request_payload: json!({"amount": 100}),
+        response_payload: None,
+        created_at: timestamp("2026-03-25T12:01:00Z"),
+        expires_at: timestamp("2027-03-25T12:06:00Z"),
+        decided_at: None,
+        decided_by_key_id: None,
+        decision_note: None,
+    };
+
+    registry
+        .create_operation(&workspace_id, &operation, None)
+        .await
+        .unwrap();
+    registry
+        .create_agent(CreateAgentRequest {
+            agent: &agent,
+            version: &version,
+            bindings: &[],
+        })
+        .await
+        .unwrap();
+    registry
+        .create_platform_api_key(CreatePlatformApiKeyRequest {
+            api_key: &approval_key,
+            secret_hash: "approval-secret-hash",
+        })
+        .await
+        .unwrap();
+    registry
+        .create_approval_request(CreateApprovalRequest {
+            approval: &approval,
+        })
+        .await
+        .unwrap();
+
+    let pending = registry
+        .list_pending_approval_requests_for_agent(&workspace_id, &agent.id)
+        .await
+        .unwrap();
+    assert_eq!(pending.len(), 1);
+    assert_eq!(pending[0].approval, approval);
+
+    let workspace_approvals = registry
+        .list_approval_requests(ListApprovalRequestsQuery {
+            workspace_id: &workspace_id,
+            status: None,
+            limit: 10,
+        })
+        .await
+        .unwrap();
+    assert_eq!(workspace_approvals.len(), 1);
+    assert_eq!(workspace_approvals[0].approval.id, approval.id);
+
+    let fetched = registry
+        .get_approval_request(&workspace_id, &approval.id)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(fetched.approval, approval);
+
+    let decided = registry
+        .decide_approval_request(DecideApprovalRequest {
+            workspace_id: &workspace_id,
+            agent_id: &agent.id,
+            approval_id: &approval.id,
+            status: ApprovalRequestStatus::Approved,
+            decided_at: timestamp("2026-03-25T12:02:00Z"),
+            decided_by_key_id: &approval_key.id,
+            response_payload: Some(json!({"approve": "yes"})),
+            decision_note: Some("confirmed in test"),
+        })
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(decided.approval.status, ApprovalRequestStatus::Approved);
+    assert_eq!(
+        decided.approval.decided_by_key_id,
+        Some(approval_key.id.clone())
+    );
+    assert_eq!(
+        decided.approval.response_payload,
+        Some(json!({"approve": "yes"}))
+    );
+
+    let completed = registry
+        .finish_approval_request(FinishApprovalRequest {
+            workspace_id: &workspace_id,
+            agent_id: &agent.id,
+            approval_id: &approval.id,
+            status: ApprovalRequestStatus::Completed,
+            response_payload: Some(json!({"id": "lead_123"})),
+            decision_note: None,
+        })
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(completed.approval.status, ApprovalRequestStatus::Completed);
+    assert_eq!(
+        completed.approval.response_payload,
+        Some(json!({"id": "lead_123"}))
+    );
+
+    let completed_by_status = registry
+        .list_approval_requests(ListApprovalRequestsQuery {
+            workspace_id: &workspace_id,
+            status: Some(ApprovalRequestStatus::Completed),
+            limit: 10,
+        })
+        .await
+        .unwrap();
+    assert_eq!(completed_by_status.len(), 1);
+    assert_eq!(
+        completed_by_status[0].approval.status,
+        ApprovalRequestStatus::Completed
+    );
+
+    let pending_after_decision = registry
+        .list_pending_approval_requests_for_agent(&workspace_id, &agent.id)
+        .await
+        .unwrap();
+    assert!(pending_after_decision.is_empty());
+
+    let repeated_decision = registry
+        .decide_approval_request(DecideApprovalRequest {
+            workspace_id: &workspace_id,
+            agent_id: &agent.id,
+            approval_id: &approval.id,
+            status: ApprovalRequestStatus::Denied,
+            decided_at: timestamp("2026-03-25T12:03:00Z"),
+            decided_by_key_id: &approval_key.id,
+            response_payload: Some(json!({"approve": "no"})),
+            decision_note: None,
+        })
+        .await
+        .unwrap();
+    assert!(repeated_decision.is_none());
+
+    database.cleanup().await;
+}

crates/crank-runtime/src/idempotency.rs

@@ -85,10 +85,9 @@ fn key_from_policy(
         .header_name
         .as_deref()
         .filter(|value| !value.is_empty())
+        && let Some(value) = prepared_request.headers.get(header_name)
     {
-        if let Some(value) = prepared_request.headers.get(header_name) {
-            return Some(value.clone());
-        }
+        return Some(value.clone());
     }
 
     let field_name = policy.input_field.as_deref()?.trim();

crates/crank-runtime/tests/integration/confirmation.rs

@@ -160,6 +160,7 @@ fn destructive_delete_operation() -> Operation<Schema, MappingSet> {
                 class: OperationSafetyClass::Destructive,
                 confirmation: Some(ConfirmationPolicy { ttl_ms: 60_000 }),
             }),
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },

crates/crank-runtime/tests/integration/idempotency.rs

@@ -146,6 +146,7 @@ fn idempotent_post_operation() -> Operation<Schema, MappingSet> {
                 header_name: Some("Idempotency-Key".to_owned()),
             }),
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },

crates/crank-runtime/tests/integration/no_input_get.rs

@@ -71,6 +71,7 @@ fn no_input_get_operation() -> Operation<Schema, MappingSet> {
             response_cache: None,
             idempotency: None,
             safety: None,
+            approval_policy: None,
             auth_profile_ref: None,
             headers: BTreeMap::new(),
         },

crates/crank-test-support/src/lib.rs

@@ -28,7 +28,9 @@ pub async fn postgres_schema_url(prefix: &str) -> String {
     let mut connection = connect_admin_with_retry(database_url).await;
 
     connection
-        .execute(sqlx::query(&format!("create schema {schema}")))
+        .execute(sqlx::query(sqlx::AssertSqlSafe(format!(
+            "create schema {schema}"
+        ))))
         .await
         .expect("test PostgreSQL schema must be created");
 

docs/README.md

@@ -16,6 +16,7 @@ Crank превращает REST API endpoint-ы в MCP-инструменты,
 
 - [Веб-интерфейс](./ui.md)
 - [REST-инструменты](./protocols/rest.md)
+- [Импорт OpenAPI](./openapi-import.md)
 - [Секреты и профили авторизации](./secrets-and-auth.md)
 - [Журналы и использование](./observability.md)
 - [Проектирование MCP-инструментов](./tool-design.md)

docs/mcp-interface.md

@@ -32,6 +32,8 @@ Authorization: Bearer <agent_api_key>
 
 Ключ выдается в разделе **API ключи**. Полное значение показывается только один раз при создании.
 
+Для операций с подтверждением человеком нужен отдельный ключ подтверждения. Его тоже выдают в разделе **API ключи**, но в режиме **Подтверждения**. Такой ключ нельзя передавать LLM или MCP-клиенту. Он нужен только вашему внешнему интерфейсу, где пользователь нажимает «Подтвердить» или «Отклонить».
+
 ## Поддерживаемые методы
 
 MCP methods:
@@ -148,6 +150,68 @@ Crank выполнит REST-запрос:
 GET https://api.frankfurter.dev/v1/latest?base=USD&symbols=EUR
 ```
 
+## Операции с подтверждением человеком
+
+Если в мастере операции включено **Подтверждение человеком**, первый `tools/call` не выполняет REST-запрос сразу. Вместо этого Crank создает ожидающий запрос на подтверждение и возвращает MCP-клиенту структурированный результат:
+
+```json
+{
+  "status": "approval_required",
+  "approval_id": "approval_...",
+  "approval_url": "/v1/default/sales/approvals/approval_...",
+  "approve": {
+    "method": "POST",
+    "url": "/v1/default/sales/approvals/approval_.../approve",
+    "body": { "approve": "yes" }
+  },
+  "deny": {
+    "method": "POST",
+    "url": "/v1/default/sales/approvals/approval_.../deny",
+    "body": { "approve": "no" }
+  }
+}
+```
+
+`approval_url` в ответе является путем на MCP-сервере. Если вы публикуете MCP через префикс `/mcp`, внешний URL будет начинаться с `/mcp/v1/...`.
+
+Внешний интерфейс подтверждения работает отдельным ключом подтверждения:
+
+```bash
+curl https://crank.example.com/mcp/v1/default/sales/approvals \
+  -H 'Authorization: Bearer <approval_api_key>'
+```
+
+Статус конкретного запроса:
+
+```bash
+curl https://crank.example.com/mcp/v1/default/sales/approvals/<approval_id> \
+  -H 'Authorization: Bearer <approval_api_key>'
+```
+
+Подтверждение:
+
+```bash
+curl https://crank.example.com/mcp/v1/default/sales/approvals/<approval_id>/approve \
+  -H 'Authorization: Bearer <approval_api_key>' \
+  -H 'Content-Type: application/json' \
+  --data '{ "approve": "yes", "note": "Пользователь подтвердил действие" }'
+```
+
+После подтверждения Crank выполняет исходный REST-запрос с тем payload, который был сохранен при первом `tools/call`. Если запрос прошел успешно, заявка получает статус `completed`, а результат сохраняется в `response_payload`. Если upstream вернул ошибку, заявка получает статус `failed`, а в `response_payload` сохраняется код и текст ошибки.
+
+Отклонение:
+
+```bash
+curl https://crank.example.com/mcp/v1/default/sales/approvals/<approval_id>/deny \
+  -H 'Authorization: Bearer <approval_api_key>' \
+  -H 'Content-Type: application/json' \
+  --data '{ "approve": "no", "note": "Пользователь отклонил действие" }'
+```
+
+Ключ MCP-клиента не подходит для этих endpoints. Ключ подтверждения, наоборот, не подходит для `initialize`, `tools/list` и `tools/call`.
+
+Текущая реализация возвращает `approval_required` сразу и не держит исходный `tools/call` открытым до решения пользователя. Поэтому внешний интерфейс может восстановить результат через `GET /approvals/<approval_id>`. Долгое ожидание через Streamable HTTP/SSE запланировано отдельно.
+
 ## Как формируется каталог инструментов
 
 MCP-клиент видит только опубликованные операции, которые привязаны к опубликованному агенту.

docs/openapi-import.md

@@ -0,0 +1,63 @@
+# Импорт OpenAPI
+
+Crank умеет импортировать REST API из OpenAPI 3.x и Swagger 2.0 документов. Импорт создает черновики MCP-инструментов, которые можно проверить и доработать в мастере операции перед публикацией.
+
+## Как импортировать
+
+1. Откройте раздел **Операции**.
+2. Нажмите **Импорт OpenAPI** рядом с кнопкой **Новая операция**.
+3. Загрузите `.yaml`, `.yml`, `.json` файл или вставьте текст спецификации.
+4. Нажмите **Разобрать документ**.
+5. Проверьте preview: для каждого метода показываются поля `Path`, `Query`, `Header`, `Body` и поля ответа.
+6. Выберите нужные группы и методы.
+7. Проверьте `Base URL`. Если в документе нет `servers`, укажите URL вручную.
+8. Выберите поведение при конфликте имени:
+   - **Создать копию с новым именем** — Crank добавит суффикс `_2`, `_3` и так далее.
+   - **Пропустить** — существующие операции не будут изменены.
+9. Нажмите **Создать черновики**.
+
+## Что создается
+
+Для каждого выбранного метода Crank создает отдельную операцию в статусе черновика:
+
+- имя инструмента берется из `operationId`, а если его нет — строится из HTTP-метода и пути;
+- отображаемое имя берется из `summary`;
+- описание инструмента берется из `description`;
+- группа берется из первого `tag`;
+- query/path/header параметры становятся входными параметрами MCP-инструмента;
+- JSON `requestBody` с объектной схемой раскладывается в отдельные входные поля;
+- схема успешного ответа берется из `200`, `201`, `202` или `default`.
+
+После импорта откройте созданный черновик в мастере операции. На шаге **Связи полей** Crank покажет уже созданный маппинг в визуальном виде:
+
+- `Path` — параметры из пути, например `/users/{id}`;
+- `Query` — query-параметры URL;
+- `Header` — заголовки запроса;
+- `Body` — поля JSON-тела.
+
+YAML-маппинг остается доступен в блоке **Дополнительно**, но для обычной настройки его редактировать не нужно.
+
+## Рекомендации
+
+После разбора Crank показывает предупреждения, если в спецификации не хватает данных для качественного MCP-инструмента:
+
+- нет `operationId`;
+- нет `summary` или `description`;
+- нет схемы успешного ответа;
+- нет `servers`;
+- слишком много входных параметров;
+- используется тело запроса без JSON-схемы.
+
+Эти предупреждения не блокируют импорт, но перед публикацией лучше открыть созданную операцию и проверить:
+
+- описание инструмента;
+- входные поля и их обязательность;
+- связи `Path / Query / Header / Body`;
+- пример входных данных для теста;
+- поля ответа, которые увидит MCP клиент.
+
+## Ограничения Community
+
+В Community импортируются только REST/HTTP методы: `GET`, `POST`, `PUT`, `PATCH`, `DELETE`.
+
+Другие форматы спецификаций и протоколов в Community-импорт не входят.

docs/protocols/rest.md

@@ -55,11 +55,11 @@ REST operation в системе описывается следующими о
 2. Выбирает HTTP method.
 3. Указывает `path_template`.
 4. При необходимости загружает пример входного и выходного `JSON`.
-5. Система строит черновую схему и стартовый mapping.
+5. Система строит черновую схему и стартовые связи полей.
 6. Описывает или уточняет входные MCP-параметры.
-7. Сопоставляет параметры с `path`, `query`, `headers` и `body`.
+7. Сопоставляет параметры с `Path`, `Query`, `Header` и `Body` в визуальном конструкторе.
 8. Указывает, откуда извлекать полезные данные в ответе.
-9. При необходимости уточняет mapping через `JSONPath`.
+9. При необходимости открывает блок **Дополнительно** и уточняет YAML/JSONPath вручную.
 10. Запускает тест.
 11. Публикует operation как MCP tool.
 
@@ -80,7 +80,7 @@ Output mapping должен поддерживать:
 - извлечение вложенных полей
 - нормализацию отсутствующих значений
 
-`JSONPath` является основным способом адресации конкретных параметров при работе со вложенными объектами и массивами.
+В интерфейсе пользователь работает с таблицей связей. `JSONPath` остается внутренним форматом и расширенным режимом для сложных случаев.
 
 ## 7. Поведение runtime
 

docs/ui.md

@@ -19,6 +19,34 @@
 
 Черновик можно редактировать и тестировать. MCP-клиенты видят только опубликованные операции, которые привязаны к опубликованному агенту.
 
+### Создание операции
+
+В мастере операции основной сценарий такой:
+
+1. Выбрать REST.
+2. Выбрать upstream или добавить новый `Base URL`.
+3. Указать HTTP-метод и путь endpoint-а.
+4. Описать инструмент и его входную/выходную схему.
+5. Загрузить или вставить JSON-пример запроса и ответа.
+6. Связать поля инструмента с `Path`, `Query`, `Header` и `Body`.
+7. Выбрать поля ответа API, которые вернет MCP-инструмент.
+8. Запустить тест.
+9. Сохранить и опубликовать операцию.
+
+Для обычной работы достаточно визуального конструктора связей. YAML/JSONPath открыт в блоке **Дополнительно** для сложных случаев: вложенные поля, ручная правка, перенос готовой конфигурации.
+
+Если пример ответа содержит массив, визуальное дерево показывает поля первого элемента как `items[0].name`. Это удобно, когда агенту нужно одно конкретное поле. Если агенту нужен весь список, используйте блок **Дополнительно** и верните массив целиком.
+
+### Импорт OpenAPI
+
+Кнопка **Импорт OpenAPI** создает черновики операций из OpenAPI/Swagger. После импорта откройте черновик в мастере и проверьте:
+
+- описание инструмента;
+- входные поля;
+- связи `Path / Query / Header / Body`;
+- пример тестового запроса;
+- поля ответа, которые попадут в результат инструмента.
+
 ## Агенты
 
 Агент - это отдельный MCP endpoint с выбранным набором инструментов.
@@ -32,12 +60,16 @@
 
 ## API ключи
 
-API-ключ выдается на конкретного агента. Ключ позволяет MCP-клиенту:
+API-ключ выдается на конкретного агента. В Community есть два режима ключей.
+
+Ключ MCP-клиента позволяет:
 
 - открыть MCP-сессию;
 - получить список инструментов агента;
 - вызвать опубликованный инструмент.
 
+Ключ подтверждения используется только внешним интерфейсом, где человек подтверждает или отклоняет опасное действие. Такой ключ нельзя передавать MCP-клиенту или LLM.
+
 Полное значение ключа показывается только при создании.
 
 ## Секреты
@@ -51,4 +83,3 @@ API-ключ выдается на конкретного агента. Ключ
 Раздел **Логи** показывает вызовы операций, ошибки маппинга, ошибки REST API и успешные ответы.
 
 Раздел **Использование** показывает количество вызовов, ошибки и задержки по операциям.
-