Fix docs link

Signed-off-by: Drasko Draskovic <drasko.draskovic@gmail.com>
2026-08-07 23:31:55 +00:00 · 2024-04-14 17:47:07 +02:00
216 changed files with 4238 additions and 24489 deletions
@@ -0,0 +1,33 @@
+## Jaeger
+COCOS_JAEGER_PORT=6831
+COCOS_JAEGER_FRONTEND=16686
+COCOS_JAEGER_COLLECTOR=14268
+COCOS_JAEGER_CONFIGS=5778
+COCOS_JAEGER_URL=http://jaeger:14268/api/traces
+COCOS_JAEGER_TRACE_RATIO=1.0
+
+## Core Services
+
+### Manager
+MANAGER_HTTP_HOST="cocos-manager"
+MANAGER_HTTP_PORT=9021
+MANAGER_HTTP_SERVER_CERT=""
+MANAGER_HTTP_SERVER_KEY=""
+MANAGER_GRPC_HOST="cocos-manager"
+MANAGER_GRPC_PORT=7003
+MANAGER_GRPC_SERVER_CERT=""
+MANAGER_GRPC_SERVER_KEY=""
+AGENT_GRPC_URL="192.168.100.4:7002"
+AGENT_GRPC_TIMEOUT=""
+AGENT_GRPC_CA_CERTS=""
+AGENT_GRPC_CLIENT_TLS=""
+MANAGER_INSTANCE_ID=""
+MANAGER_LOG_LEVEL=debug
+MANAGER_QEMU_USE_SUDO=false
+MANAGER_QEMU_ENABLE_SEV=false
+MANAGER_QEMU_SEV_CBITPOS=51
+MANAGER_QEMU_OVMF_CODE_FILE=/usr/share/OVMF/OVMF_CODE.fd
+MANAGER_QEMU_OVMF_VARS_FILE=/usr/share/OVMF/OVMF_VARS.fd
+
+# Docker image tag
+COCOS_RELEASE_TAG=latest
@@ -1,22 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/scripts/attestation_policy"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      rs-dependencies:
-        patterns:
-          - "*"
-
-  - package-ecosystem: "gomod"
-    directories:
-      - "/"
-    schedule:
-      interval: "weekly"
-      day: "monday"
-    groups:
-      go-dependency:
-        patterns:
-          - "*"
@@ -29,13 +29,13 @@ jobs:
      - name: Install Go
        uses: actions/setup-go@v5
        with:
-          go-version: 1.23.x
+          go-version: 1.21.x

      - name: Set up protoc
        run: |
-          PROTOC_VERSION=28.1
-          PROTOC_GEN_VERSION=v1.34.2
-          PROTOC_GRPC_VERSION=v1.5.1
+          PROTOC_VERSION=25.2
+          PROTOC_GEN_VERSION=v1.31.0
+          PROTOC_GRPC_VERSION=v1.3.0

          # Download and install protoc
          PROTOC_ZIP=protoc-$PROTOC_VERSION-linux-x86_64.zip
@@ -8,66 +8,66 @@ on:
 jobs:
  build:
    runs-on: ubuntu-latest
-    timeout-minutes: 120
+
    steps:
-      - name: Free Disk Space
-        run: |
-          sudo apt-get clean
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /opt/ghc
-          sudo rm -rf "/usr/local/share/boost"
-          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
-          df -h
+    - name: Update Ubuntu
+      run: |
+        sudo apt-get update
+        sudo apt-get upgrade -y
+    
+    - name: Install Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: 1.21.x
+        cache-dependency-path: "go.sum"

-      - name: Update Ubuntu
-        run: |
-          sudo apt-get update
-          sudo apt-get upgrade -y
-          sudo apt-get clean
-          sudo apt-get autoremove -y
-          df -h
+    - name: Checkout cocos
+      uses: actions/checkout@v4
+      with:
+        repository: 'ultravioletrs/cocos'
+        path: cocos

-      - name: Maximize build space
-        uses: easimon/maximize-build-space@master
-        with:
-          root-reserve-mb: 35000
-          swap-size-mb: 1024
-          remove-dotnet: 'true'
-          remove-android: 'true'
-      - name: Check free space
-        run: |
-          echo "Free space:"
-          df -h
+    - name: Checkout buildroot
+      uses: actions/checkout@v4
+      with:
+        repository: 'buildroot/buildroot'
+        path: buildroot

-      - name: Install Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: 1.23.x
-          cache-dependency-path: "go.sum"
+    - name: Build
+      run: |
+        cd buildroot
+        make BR2_EXTERNAL=../cocos/hal/linux cocos_defconfig
+        make

-      - name: Checkout cocos
-        uses: actions/checkout@v4
-        with:
-          repository: 'ultravioletrs/cocos'
-          path: cocos
+    - name: Create Release
+      id: create_release
+      uses: actions/create-release@latest
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: Release ${{ github.ref }}
+        draft: false
+        prerelease: false

-      - name: Checkout buildroot
-        uses: actions/checkout@v4
-        with:
-          repository: 'buildroot/buildroot'
-          path: buildroot
-          ref: 2024.11-rc2
-
-      - name: Build
-        run: |
-          cd buildroot
-          make BR2_EXTERNAL=../cocos/hal/linux cocos_defconfig
-          make
-
-      - name: Release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: |
-            buildroot/output/images/bzImage
-            buildroot/output/images/rootfs.cpio.gz
+    - name: Upload Release Asset
+      id: upload-release-kernel
+      uses: actions/upload-release-asset@latest
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./buildroot/output/images/bzImage
+        asset_name: bzImage
+        asset_content_type: application/octet-stream

+    - name: Upload Release Asset
+      id: upload-release-rootfs
+      uses: actions/upload-release-asset@latest
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./buildroot/output/images/rootfs.cpio.gz
+        asset_name: rootfs.cpio.gz
+        asset_content_type: application/gzip
@@ -19,43 +19,16 @@ jobs:
      - name: Install Go
        uses: actions/setup-go@v5
        with:
-          go-version: 1.23.x
+          go-version: 1.21.x

      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v3
        with:
-          version: v1.60
+          version: latest

      - name: Build
        run: |
          make

-      - name: Create coverage directory
-        run: |
-          mkdir coverage
-
-      - name: Run Agent tests
-        run: go test -v --race -covermode=atomic -coverprofile coverage/agent.out ./agent/...
-
-      - name: Run cli tests
-        run: go test -v --race -covermode=atomic -coverprofile coverage/cli.out ./cli/...
-
-      - name: Run cmd tests
-        run: go test -v --race -covermode=atomic -coverprofile coverage/cmd.out ./cmd/...
-
-      - name: Run internal tests
-        run: go test -v --race -covermode=atomic -coverprofile coverage/internal.out ./internal/...
-
-      - name: Run pkg tests
-        run: go test -v --race -covermode=atomic -coverprofile coverage/pkg.out ./pkg/...
-
-      - name: Run manager tests
-        run: sudo go test -v --race -covermode=atomic -coverprofile coverage/manager.out ./manager/...
-
-      - name: Upload results to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          files: ./coverage/*.out
-          codecov_yml_path: codecov.yml
-          verbose: true
+      - name: Run tests
+        run: go test -v --race -covermode=atomic -coverprofile cover.out ./...
@@ -1,41 +0,0 @@
-name: Rust CI Pipeline
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "scripts/attestation_policy/**"
-      - ".github/workflows/rust.yaml"
-  pull_request:
-    branches:
-      - main
-    paths:
-      - "scripts/attestation_policy/**"
-      - ".github/workflows/rust.yaml"
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  rust-check:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./scripts/attestation_policy
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Check cargo
-        run: cargo check --release --all-targets
-
-      - name: Check formatting
-        run: cargo fmt --all -- --check
-
-      - name: Run linter
-        run: cargo clippy -- -D warnings
-
-      - name: Build for all features
-        run: cargo build --release --all-features
@@ -1,27 +1,8 @@
 build

+build
 cmd/manager/img
+cmd/manager/iso
+cmd/manager/tmp

 .cov
-
-*.pem
-
-dist/
-*.zip
-*.spec
-*.tar
-
-# Generated by Cargo
-# will have compiled files and executables
-debug/
-target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
-
-# These are backup files generated by rustfmt
-**/*.rs.bk
-
-# MSVC Windows builds of rustc generate these, which store debugging information
-*.pdb
@@ -1,6 +1,6 @@
 run:
  timeout: 3m
-
+  
 issues:
  max-issues-per-linter: 10
  max-same-issues: 10
@@ -15,7 +15,10 @@ linters-settings:

  gocritic:
    enabled-checks:
+      - captLocal
      - dupImport
+      - singleCaseSwitch
+      - switchTrue
      - importShadow
      - httpNoBody
      - paramTypeCombine
@@ -31,6 +34,9 @@ linters-settings:
      - style
      - experimental
      - opinionated
+  misspell:
+    ignore-words:
+      - "mosquitto"
  stylecheck:
    checks: ["-ST1000", "-ST1003", "-ST1020", "-ST1021", "-ST1022"]
  goheader:
@@ -68,7 +74,7 @@ linters:
    - errchkjson
    - errname
    - execinquery
-    - copyloopvar
+    - exportloopref
    - ginkgolinter
    - gocheckcompilerdirectives
    - gofumpt
@@ -77,4 +83,4 @@ linters:
    - makezero
    - mirror
    - nakedret
-    - dupword
+    - dupword
@@ -1,17 +1,12 @@
 BUILD_DIR = build
 SERVICES = manager agent cli
-ATTESTATION_POLICY = attestation_policy
-CGO_ENABLED ?= 1
+CGO_ENABLED ?= 0
 GOARCH ?= amd64
 VERSION ?= $(shell git describe --abbrev=0 --tags --always)
 COMMIT ?= $(shell git rev-parse HEAD)
 TIME ?= $(shell date +%F_%T)
-EMBED_ENABLED ?= 0
-INSTALL_DIR ?= /usr/local/bin
-CONFIG_DIR ?= /etc/cocos
-SERVICE_NAME ?= cocos-manager
-SERVICE_DIR ?= /etc/systemd/system
-SERVICE_FILE = init/systemd/$(SERVICE_NAME).service
+empty:=
+space:= $(empty) $(empty)

 define compile_service
 	CGO_ENABLED=$(CGO_ENABLED) GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
@@ -19,44 +14,16 @@ define compile_service
 	-X 'github.com/absmach/magistrala.BuildTime=$(TIME)' \
 	-X 'github.com/absmach/magistrala.Version=$(VERSION)' \
 	-X 'github.com/absmach/magistrala.Commit=$(COMMIT)'" \
-	$(if $(filter 1,$(EMBED_ENABLED)),-tags "embed",) \
 	-o ${BUILD_DIR}/cocos-$(1) cmd/$(1)/main.go
 endef

-.PHONY: all $(SERVICES) $(ATTESTATION_POLICY) install clean
+.PHONY: all $(SERVICES)

 all: $(SERVICES)

 $(SERVICES):
-	$(call compile_service,$@)
-
-$(ATTESTATION_POLICY):
-	$(MAKE) -C ./scripts/attestation_policy
+	$(call compile_service,$(@))

 protoc:
 	protoc -I. --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative agent/agent.proto
-	protoc -I. --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative manager/manager.proto
-	protoc -I. --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative agent/events/events.proto
-
-mocks:
-	mockery --config ./mockery.yml
-
-install: $(SERVICES)
-	install -d $(INSTALL_DIR)
-	install $(BUILD_DIR)/cocos-cli $(INSTALL_DIR)/cocos-cli
-	install $(BUILD_DIR)/cocos-manager $(INSTALL_DIR)/cocos-manager
-	install -d $(CONFIG_DIR)
-	install cocos-manager.env $(CONFIG_DIR)/cocos-manager.env
-
-clean:
-	rm -rf $(BUILD_DIR)
-
-run: install_service
-	sudo systemctl start $(SERVICE_NAME).service
-
-stop:
-	sudo systemctl stop $(SERVICE_NAME).service
-
-install_service:
-	sudo install -m 644 $(SERVICE_FILE) $(SERVICE_DIR)/$(SERVICE_NAME).service
-	sudo systemctl daemon-reload
+	protoc -I. --go_out=./pkg --go_opt=paths=source_relative --go-grpc_out=./pkg --go-grpc_opt=paths=source_relative manager/manager.proto
@@ -1,8 +1,4 @@
 # Cocos AI
-
-[![codecov](https://codecov.io/gh/ultravioletrs/cocos/graph/badge.svg?token=HX01LR01K9)](https://codecov.io/gh/ultravioletrs/cocos)
-![Go report card](https://goreportcard.com/badge/github.com/ultravioletrs/cocos)
-
 [Cocos AI (Confdential Computing System for AI/ML)][cocos] is a platform for secure multiparty computation (SMPC)
 based on the [Confidential Computing][cc] and [Trusted Execution Environments (TEEs)][tee].

@@ -11,55 +7,34 @@ based on the [Confidential Computing][cc] and [Trusted Execution Environments (T
 </p>

 With Cocos AI it becomes possible to run AI/ML workloads on combined datasets from multiple organizations
-while guaranteeing the privacy and security of the data and the algorithm.
+while guaranteeing the privacy and security of the data and the algorithms.
 Data is always encrypted, protected by hardware secure enclaves (Trusted Execution Environments),
 attested via secure remote attestation protocols, and invisible to cloud processors or any other
 3rd party to which computation is offloaded.

-## Features
-
-Cocos AI is implementing the following features:
-
- TEE enablement, deployment and monitoring (secure VM manager)
- HAL for TEEs based on hardened Linux kernel, secure bootloader and custom-tailored embedded rootfs for minimal TCB
- In-enclave agent, netowrking controller and other system software
- Encrypted asynchronous data transfer and result delivery
- API for programmable platform manipulation
- HW and SW supported attestation with verification tools
- CLI for system interaction
-
 ## Usage

-Clone the repo and create binaries:
+The quickest way to start using Cocos is via the CLI. The latest version can be downloaded from the [official releases page][rel].
+
+It can also be built and used from the project's root directory:

 ```bash
-git clone git@github.com:ultravioletrs/cocos.git
-make
+make cli
+./build/cocos-cli version
 ```

-This will create 3 binaries:
-```bash
-ls build/
-# cocos-agent  cocos-cli  cocos-manager
-```
-
- Manager can be deployed on the AMD SEV-SNP host
- Agent can be built into [EOS][eos]-based HAL
- CLI can be used to communicate to remote Agent.
+Additional details on using the CLI can be found in the [CLI documentation](https://docs.cocos.ai/cli).

 ## Documentation

-Project documentation is hosted at [Cocos AI official docs page][docs].
-
-Documentation is generated from the [docs repository](https://github.com/ultravioletrs/docs).
+Official documentation is hosted at [Cocos official docs page][docs]. Documentation is auto-generated, checkout the instructions on [official docs repository](https://github.com/ultravioletrs/docs).

 ## License
-Cocos AI is published under permissive open-source [Apache-2.0](LICENSE) license.
+Cocos AI is a proprietary product created by Ultraviolet company.

 [cc]: https://confidentialcomputing.io/white-papers-reports/
 [cocos]: https://cocos.ai/
-[rel]: https://github.com/ultravioletrs/cocos/releases
+[rel]: https://github.com/ultraviolet/cocos/releases
 [tee]: https://en.wikipedia.org/wiki/Trusted_execution_environment
 [docs]: https://docs.cocos.ultraviolet.rs
-[cli]: https://docs.cocos.ultraviolet.rs/cli
-[eos]: https://github.com/ultravioletrs/eos
+
@@ -15,6 +15,7 @@ The service is configured using the environment variables from the following tab
 | AGENT_GRPC_SERVER_KEY         | Path to gRPC server key in pem format                  | ""                             |
 | AGENT_GRPC_SERVER_CA_CERTS    | Path to gRPC server CA certificate                     | ""                             |
 | AGENT_GRPC_CLIENT_CA_CERTS    | Path to gRPC client CA certificate                     | ""                             |
+| COCOS_NOTIFICATION_SERVER_URL | Server to receive notification events from agent.      | http:/localhost:9000           |


 ## Deployment
@@ -3,8 +3,8 @@

 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.34.2
-// 	protoc        v5.28.1
+// 	protoc-gen-go v1.31.0
+// 	protoc        v4.25.2
 // source: agent/agent.proto

 package agent
@@ -28,8 +28,9 @@ type AlgoRequest struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields

-	Algorithm    []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
-	Requirements []byte `protobuf:"bytes,2,opt,name=requirements,proto3" json:"requirements,omitempty"`
+	Algorithm []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
+	Provider  string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id        string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }

 func (x *AlgoRequest) Reset() {
@@ -71,11 +72,18 @@ func (x *AlgoRequest) GetAlgorithm() []byte {
 	return nil
 }

-func (x *AlgoRequest) GetRequirements() []byte {
+func (x *AlgoRequest) GetProvider() string {
 	if x != nil {
-		return x.Requirements
+		return x.Provider
 	}
-	return nil
+	return ""
+}
+
+func (x *AlgoRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
 }

 type AlgoResponse struct {
@@ -122,7 +130,8 @@ type DataRequest struct {
 	unknownFields protoimpl.UnknownFields

 	Dataset  []byte `protobuf:"bytes,1,opt,name=dataset,proto3" json:"dataset,omitempty"`
-	Filename string `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"`
+	Provider string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id       string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }

 func (x *DataRequest) Reset() {
@@ -164,9 +173,16 @@ func (x *DataRequest) GetDataset() []byte {
 	return nil
 }

-func (x *DataRequest) GetFilename() string {
+func (x *DataRequest) GetProvider() string {
 	if x != nil {
-		return x.Filename
+		return x.Provider
+	}
+	return ""
+}
+
+func (x *DataRequest) GetId() string {
+	if x != nil {
+		return x.Id
 	}
 	return ""
 }
@@ -213,6 +229,8 @@ type ResultRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Consumer string `protobuf:"bytes,1,opt,name=consumer,proto3" json:"consumer,omitempty"`
 }

 func (x *ResultRequest) Reset() {
@@ -247,6 +265,13 @@ func (*ResultRequest) Descriptor() ([]byte, []int) {
 	return file_agent_agent_proto_rawDescGZIP(), []int{4}
 }

+func (x *ResultRequest) GetConsumer() string {
+	if x != nil {
+		return x.Consumer
+	}
+	return ""
+}
+
 type ResultResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -392,45 +417,48 @@ var File_agent_agent_proto protoreflect.FileDescriptor

 var file_agent_agent_proto_rawDesc = []byte{
 	0x0a, 0x11, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x12, 0x05, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x22, 0x4f, 0x0a, 0x0b, 0x41, 0x6c,
+	0x6f, 0x74, 0x6f, 0x12, 0x05, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x22, 0x57, 0x0a, 0x0b, 0x41, 0x6c,
 	0x67, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x67,
 	0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x61, 0x6c,
-	0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x69,
-	0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x72,
-	0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x41,
-	0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x43, 0x0a, 0x0b, 0x44,
-	0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x61,
-	0x74, 0x61, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x64, 0x61, 0x74,
-	0x61, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-	0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x0f, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x22, 0x24, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x35, 0x0a, 0x12, 0x41, 0x74, 0x74, 0x65, 0x73,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a,
-	0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x29,
-	0x0a, 0x13, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x32, 0xfd, 0x01, 0x0a, 0x0c, 0x41, 0x67,
-	0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x04, 0x41, 0x6c,
-	0x67, 0x6f, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41,
-	0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12,
-	0x33, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e,
-	0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67,
-	0x65, 0x6e, 0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x00, 0x28, 0x01, 0x12, 0x39, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x14,
+	0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x76, 0x69,
+	0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x76, 0x69,
+	0x64, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x02, 0x69, 0x64, 0x22, 0x0e, 0x0a, 0x0c, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x53, 0x0a, 0x0b, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x07, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08,
+	0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
+	0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, 0x61,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x75,
+	0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x6e,
+	0x73, 0x75, 0x6d, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x6e,
+	0x73, 0x75, 0x6d, 0x65, 0x72, 0x22, 0x24, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x35, 0x0a, 0x12, 0x41,
+	0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x44, 0x61,
+	0x74, 0x61, 0x22, 0x29, 0x0a, 0x13, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x32, 0xf5, 0x01,
+	0x0a, 0x0c, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x31,
+	0x0a, 0x04, 0x41, 0x6c, 0x67, 0x6f, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41,
+	0x6c, 0x67, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65,
+	0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x00, 0x12, 0x31, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e,
+	0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e,
+	0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x12, 0x37, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x14,
 	0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71,
 	0x75, 0x65, 0x73, 0x74, 0x1a, 0x15, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73,
-	0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12,
-	0x48, 0x0a, 0x0b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19,
-	0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x67, 0x65, 0x6e,
-	0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x61,
-	0x67, 0x65, 0x6e, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x46, 0x0a,
+	0x0b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x2e, 0x61,
+	0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e,
+	0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x61, 0x67, 0x65, 0x6e, 0x74,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }

 var (
@@ -446,7 +474,7 @@ func file_agent_agent_proto_rawDescGZIP() []byte {
 }

 var file_agent_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
-var file_agent_agent_proto_goTypes = []any{
+var file_agent_agent_proto_goTypes = []interface{}{
 	(*AlgoRequest)(nil),         // 0: agent.AlgoRequest
 	(*AlgoResponse)(nil),        // 1: agent.AlgoResponse
 	(*DataRequest)(nil),         // 2: agent.DataRequest
@@ -478,7 +506,7 @@ func file_agent_agent_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_agent_agent_proto_msgTypes[0].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AlgoRequest); i {
 			case 0:
 				return &v.state
@@ -490,7 +518,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[1].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AlgoResponse); i {
 			case 0:
 				return &v.state
@@ -502,7 +530,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[2].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DataRequest); i {
 			case 0:
 				return &v.state
@@ -514,7 +542,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[3].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DataResponse); i {
 			case 0:
 				return &v.state
@@ -526,7 +554,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[4].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ResultRequest); i {
 			case 0:
 				return &v.state
@@ -538,7 +566,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[5].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ResultResponse); i {
 			case 0:
 				return &v.state
@@ -550,7 +578,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[6].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AttestationRequest); i {
 			case 0:
 				return &v.state
@@ -562,7 +590,7 @@ func file_agent_agent_proto_init() {
 				return nil
 			}
 		}
-		file_agent_agent_proto_msgTypes[7].Exporter = func(v any, i int) any {
+		file_agent_agent_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*AttestationResponse); i {
 			case 0:
 				return &v.state
@@ -8,27 +8,30 @@ package agent;
 option go_package = "./agent";

 service AgentService {
-  rpc Algo(stream AlgoRequest) returns (AlgoResponse) {}
-  rpc Data(stream DataRequest) returns (DataResponse) {}
-  rpc Result(ResultRequest) returns (stream ResultResponse) {}
-  rpc Attestation(AttestationRequest) returns (stream AttestationResponse) {}
+  rpc Algo(AlgoRequest) returns (AlgoResponse) {}
+  rpc Data(DataRequest) returns (DataResponse) {}
+  rpc Result(ResultRequest) returns (ResultResponse) {}
+  rpc Attestation(AttestationRequest) returns (AttestationResponse) {}
 }

 message AlgoRequest {
  bytes algorithm = 1;
-  bytes requirements = 2;
+  string provider = 2;
+  string id = 3;
 }

 message AlgoResponse {}

 message DataRequest {
  bytes dataset = 1;
-  string filename = 2;
+  string provider = 2;
+  string id = 3;
 }

 message DataResponse {}

 message ResultRequest {
+  string consumer = 1;
 }

 message ResultResponse {
@@ -3,8 +3,8 @@

 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.5.1
-// - protoc             v5.28.1
+// - protoc-gen-go-grpc v1.3.0
+// - protoc             v4.25.2
 // source: agent/agent.proto

 package agent
@@ -18,8 +18,8 @@ import (

 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.64.0 or later.
-const _ = grpc.SupportPackageIsVersion9
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7

 const (
 	AgentService_Algo_FullMethodName        = "/agent.AgentService/Algo"
@@ -32,10 +32,10 @@ const (
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type AgentServiceClient interface {
-	Algo(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[AlgoRequest, AlgoResponse], error)
-	Data(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[DataRequest, DataResponse], error)
-	Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ResultResponse], error)
-	Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[AttestationResponse], error)
+	Algo(ctx context.Context, in *AlgoRequest, opts ...grpc.CallOption) (*AlgoResponse, error)
+	Data(ctx context.Context, in *DataRequest, opts ...grpc.CallOption) (*DataResponse, error)
+	Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (*ResultResponse, error)
+	Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (*AttestationResponse, error)
 }

 type agentServiceClient struct {
@@ -46,102 +46,70 @@ func NewAgentServiceClient(cc grpc.ClientConnInterface) AgentServiceClient {
 	return &agentServiceClient{cc}
 }

-func (c *agentServiceClient) Algo(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[AlgoRequest, AlgoResponse], error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[0], AgentService_Algo_FullMethodName, cOpts...)
+func (c *agentServiceClient) Algo(ctx context.Context, in *AlgoRequest, opts ...grpc.CallOption) (*AlgoResponse, error) {
+	out := new(AlgoResponse)
+	err := c.cc.Invoke(ctx, AgentService_Algo_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &grpc.GenericClientStream[AlgoRequest, AlgoResponse]{ClientStream: stream}
-	return x, nil
+	return out, nil
 }

-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_AlgoClient = grpc.ClientStreamingClient[AlgoRequest, AlgoResponse]
-
-func (c *agentServiceClient) Data(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[DataRequest, DataResponse], error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[1], AgentService_Data_FullMethodName, cOpts...)
+func (c *agentServiceClient) Data(ctx context.Context, in *DataRequest, opts ...grpc.CallOption) (*DataResponse, error) {
+	out := new(DataResponse)
+	err := c.cc.Invoke(ctx, AgentService_Data_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &grpc.GenericClientStream[DataRequest, DataResponse]{ClientStream: stream}
-	return x, nil
+	return out, nil
 }

-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_DataClient = grpc.ClientStreamingClient[DataRequest, DataResponse]
-
-func (c *agentServiceClient) Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ResultResponse], error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[2], AgentService_Result_FullMethodName, cOpts...)
+func (c *agentServiceClient) Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (*ResultResponse, error) {
+	out := new(ResultResponse)
+	err := c.cc.Invoke(ctx, AgentService_Result_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &grpc.GenericClientStream[ResultRequest, ResultResponse]{ClientStream: stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
+	return out, nil
 }

-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_ResultClient = grpc.ServerStreamingClient[ResultResponse]
-
-func (c *agentServiceClient) Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[AttestationResponse], error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &AgentService_ServiceDesc.Streams[3], AgentService_Attestation_FullMethodName, cOpts...)
+func (c *agentServiceClient) Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (*AttestationResponse, error) {
+	out := new(AttestationResponse)
+	err := c.cc.Invoke(ctx, AgentService_Attestation_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &grpc.GenericClientStream[AttestationRequest, AttestationResponse]{ClientStream: stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
+	return out, nil
 }

-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_AttestationClient = grpc.ServerStreamingClient[AttestationResponse]
-
 // AgentServiceServer is the server API for AgentService service.
 // All implementations must embed UnimplementedAgentServiceServer
-// for forward compatibility.
+// for forward compatibility
 type AgentServiceServer interface {
-	Algo(grpc.ClientStreamingServer[AlgoRequest, AlgoResponse]) error
-	Data(grpc.ClientStreamingServer[DataRequest, DataResponse]) error
-	Result(*ResultRequest, grpc.ServerStreamingServer[ResultResponse]) error
-	Attestation(*AttestationRequest, grpc.ServerStreamingServer[AttestationResponse]) error
+	Algo(context.Context, *AlgoRequest) (*AlgoResponse, error)
+	Data(context.Context, *DataRequest) (*DataResponse, error)
+	Result(context.Context, *ResultRequest) (*ResultResponse, error)
+	Attestation(context.Context, *AttestationRequest) (*AttestationResponse, error)
 	mustEmbedUnimplementedAgentServiceServer()
 }

-// UnimplementedAgentServiceServer must be embedded to have
-// forward compatible implementations.
-//
-// NOTE: this should be embedded by value instead of pointer to avoid a nil
-// pointer dereference when methods are called.
-type UnimplementedAgentServiceServer struct{}
+// UnimplementedAgentServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedAgentServiceServer struct {
+}

-func (UnimplementedAgentServiceServer) Algo(grpc.ClientStreamingServer[AlgoRequest, AlgoResponse]) error {
-	return status.Errorf(codes.Unimplemented, "method Algo not implemented")
+func (UnimplementedAgentServiceServer) Algo(context.Context, *AlgoRequest) (*AlgoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Algo not implemented")
 }
-func (UnimplementedAgentServiceServer) Data(grpc.ClientStreamingServer[DataRequest, DataResponse]) error {
-	return status.Errorf(codes.Unimplemented, "method Data not implemented")
+func (UnimplementedAgentServiceServer) Data(context.Context, *DataRequest) (*DataResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Data not implemented")
 }
-func (UnimplementedAgentServiceServer) Result(*ResultRequest, grpc.ServerStreamingServer[ResultResponse]) error {
-	return status.Errorf(codes.Unimplemented, "method Result not implemented")
+func (UnimplementedAgentServiceServer) Result(context.Context, *ResultRequest) (*ResultResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Result not implemented")
 }
-func (UnimplementedAgentServiceServer) Attestation(*AttestationRequest, grpc.ServerStreamingServer[AttestationResponse]) error {
-	return status.Errorf(codes.Unimplemented, "method Attestation not implemented")
+func (UnimplementedAgentServiceServer) Attestation(context.Context, *AttestationRequest) (*AttestationResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Attestation not implemented")
 }
 func (UnimplementedAgentServiceServer) mustEmbedUnimplementedAgentServiceServer() {}
-func (UnimplementedAgentServiceServer) testEmbeddedByValue()                      {}

 // UnsafeAgentServiceServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to AgentServiceServer will
@@ -151,51 +119,80 @@ type UnsafeAgentServiceServer interface {
 }

 func RegisterAgentServiceServer(s grpc.ServiceRegistrar, srv AgentServiceServer) {
-	// If the following call pancis, it indicates UnimplementedAgentServiceServer was
-	// embedded by pointer and is nil.  This will cause panics if an
-	// unimplemented method is ever invoked, so we test this at initialization
-	// time to prevent it from happening at runtime later due to I/O.
-	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
-		t.testEmbeddedByValue()
-	}
 	s.RegisterService(&AgentService_ServiceDesc, srv)
 }

-func _AgentService_Algo_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(AgentServiceServer).Algo(&grpc.GenericServerStream[AlgoRequest, AlgoResponse]{ServerStream: stream})
-}
-
-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_AlgoServer = grpc.ClientStreamingServer[AlgoRequest, AlgoResponse]
-
-func _AgentService_Data_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(AgentServiceServer).Data(&grpc.GenericServerStream[DataRequest, DataResponse]{ServerStream: stream})
-}
-
-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_DataServer = grpc.ClientStreamingServer[DataRequest, DataResponse]
-
-func _AgentService_Result_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(ResultRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
+func _AgentService_Algo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlgoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
 	}
-	return srv.(AgentServiceServer).Result(m, &grpc.GenericServerStream[ResultRequest, ResultResponse]{ServerStream: stream})
-}
-
-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_ResultServer = grpc.ServerStreamingServer[ResultResponse]
-
-func _AgentService_Attestation_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(AttestationRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Algo(ctx, in)
 	}
-	return srv.(AgentServiceServer).Attestation(m, &grpc.GenericServerStream[AttestationRequest, AttestationResponse]{ServerStream: stream})
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Algo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Algo(ctx, req.(*AlgoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }

-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type AgentService_AttestationServer = grpc.ServerStreamingServer[AttestationResponse]
+func _AgentService_Data_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DataRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Data(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Data_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Data(ctx, req.(*DataRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _AgentService_Result_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ResultRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Result(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Result_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Result(ctx, req.(*ResultRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _AgentService_Attestation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AttestationRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AgentServiceServer).Attestation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: AgentService_Attestation_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AgentServiceServer).Attestation(ctx, req.(*AttestationRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}

 // AgentService_ServiceDesc is the grpc.ServiceDesc for AgentService service.
 // It's only intended for direct use with grpc.RegisterService,
@@ -203,28 +200,24 @@ type AgentService_AttestationServer = grpc.ServerStreamingServer[AttestationResp
 var AgentService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "agent.AgentService",
 	HandlerType: (*AgentServiceServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
+	Methods: []grpc.MethodDesc{
 		{
-			StreamName:    "Algo",
-			Handler:       _AgentService_Algo_Handler,
-			ClientStreams: true,
+			MethodName: "Algo",
+			Handler:    _AgentService_Algo_Handler,
 		},
 		{
-			StreamName:    "Data",
-			Handler:       _AgentService_Data_Handler,
-			ClientStreams: true,
+			MethodName: "Data",
+			Handler:    _AgentService_Data_Handler,
 		},
 		{
-			StreamName:    "Result",
-			Handler:       _AgentService_Result_Handler,
-			ServerStreams: true,
+			MethodName: "Result",
+			Handler:    _AgentService_Result_Handler,
 		},
 		{
-			StreamName:    "Attestation",
-			Handler:       _AgentService_Attestation_Handler,
-			ServerStreams: true,
+			MethodName: "Attestation",
+			Handler:    _AgentService_Attestation_Handler,
 		},
 	},
+	Streams:  []grpc.StreamDesc{},
 	Metadata: "agent/agent.proto",
 }
@@ -1,29 +0,0 @@
-// Code generated by "stringer -type=AgentEvent"; DO NOT EDIT.
-
-package agent
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[Start-0]
-	_ = x[ManifestReceived-1]
-	_ = x[AlgorithmReceived-2]
-	_ = x[DataReceived-3]
-	_ = x[RunComplete-4]
-	_ = x[ResultsConsumed-5]
-	_ = x[RunFailed-6]
-}
-
-const _AgentEvent_name = "StartManifestReceivedAlgorithmReceivedDataReceivedRunCompleteResultsConsumedRunFailed"
-
-var _AgentEvent_index = [...]uint8{0, 5, 21, 38, 50, 61, 76, 85}
-
-func (i AgentEvent) String() string {
-	if i < 0 || i >= AgentEvent(len(_AgentEvent_index)-1) {
-		return "AgentEvent(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _AgentEvent_name[_AgentEvent_index[i]:_AgentEvent_index[i+1]]
-}
@@ -1,30 +0,0 @@
-// Code generated by "stringer -type=AgentState"; DO NOT EDIT.
-
-package agent
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[Idle-0]
-	_ = x[ReceivingManifest-1]
-	_ = x[ReceivingAlgorithm-2]
-	_ = x[ReceivingData-3]
-	_ = x[Running-4]
-	_ = x[ConsumingResults-5]
-	_ = x[Complete-6]
-	_ = x[Failed-7]
-}
-
-const _AgentState_name = "IdleReceivingManifestReceivingAlgorithmReceivingDataRunningConsumingResultsCompleteFailed"
-
-var _AgentState_index = [...]uint8{0, 4, 21, 39, 52, 59, 75, 83, 89}
-
-func (i AgentState) String() string {
-	if i < 0 || i >= AgentState(len(_AgentState_index)-1) {
-		return "AgentState(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _AgentState_name[_AgentState_index[i]:_AgentState_index[i+1]]
-}
@@ -1,49 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package algorithm
-
-import (
-	"context"
-
-	"google.golang.org/grpc/metadata"
-)
-
-type AlgorithType string
-
-const (
-	AlgoTypeBin    AlgorithType = "bin"
-	AlgoTypePython AlgorithType = "python"
-	AlgoTypeWasm   AlgorithType = "wasm"
-	AlgoTypeDocker AlgorithType = "docker"
-	AlgoTypeKey                 = "algo_type"
-	AlgoArgsKey                 = "algo_args"
-
-	ResultsDir     = "results"
-	DatasetsDir    = "datasets"
-	AlgoWorkingDir = "/cocos"
-)
-
-func AlgorithmTypeToContext(ctx context.Context, algoType string) context.Context {
-	return metadata.AppendToOutgoingContext(ctx, AlgoTypeKey, algoType)
-}
-
-func AlgorithmTypeFromContext(ctx context.Context) string {
-	return metadata.ValueFromIncomingContext(ctx, AlgoTypeKey)[0]
-}
-
-func AlgorithmArgsToContext(ctx context.Context, algoArgs []string) context.Context {
-	for _, arg := range algoArgs {
-		ctx = metadata.AppendToOutgoingContext(ctx, AlgoArgsKey, arg)
-	}
-	return ctx
-}
-
-func AlgorithmArgsFromContext(ctx context.Context) []string {
-	return metadata.ValueFromIncomingContext(ctx, AlgoArgsKey)
-}
-
-// Algorithm is an interface that specifies the API for an algorithm.
-type Algorithm interface {
-	// Run executes the algorithm and returns the result.
-	Run() error
-}
@@ -1,48 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package binary
-
-import (
-	"fmt"
-	"io"
-	"log/slog"
-	"os/exec"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-var _ algorithm.Algorithm = (*binary)(nil)
-
-type binary struct {
-	algoFile string
-	stderr   io.Writer
-	stdout   io.Writer
-	args     []string
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string, args []string) algorithm.Algorithm {
-	return &binary{
-		algoFile: algoFile,
-		stderr:   &logging.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:   &logging.Stdout{Logger: logger},
-		args:     args,
-	}
-}
-
-func (b *binary) Run() error {
-	cmd := exec.Command(b.algoFile, b.args...)
-	cmd.Stderr = b.stderr
-	cmd.Stdout = b.stdout
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("error starting algorithm: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("algorithm execution error: %v", err)
-	}
-
-	return nil
-}
@@ -1,100 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package binary
-
-import (
-	"bytes"
-	"log/slog"
-	"os"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-)
-
-func TestNewAlgorithm(t *testing.T) {
-	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	eventsSvc := new(mocks.Service)
-	algoFile := "/path/to/algo"
-	args := []string{"arg1", "arg2"}
-
-	algo := NewAlgorithm(logger, eventsSvc, algoFile, args)
-
-	b, ok := algo.(*binary)
-	if !ok {
-		t.Fatalf("NewAlgorithm did not return a *binary")
-	}
-
-	if b.algoFile != algoFile {
-		t.Errorf("Expected algoFile to be %s, got %s", algoFile, b.algoFile)
-	}
-
-	if len(b.args) != len(args) {
-		t.Errorf("Expected %d args, got %d", len(args), len(b.args))
-	}
-
-	for i, arg := range args {
-		if b.args[i] != arg {
-			t.Errorf("Expected arg %d to be %s, got %s", i, arg, b.args[i])
-		}
-	}
-
-	if _, ok := b.stderr.(*logging.Stderr); !ok {
-		t.Errorf("Expected stderr to be *algorithm.Stderr")
-	}
-
-	if _, ok := b.stdout.(*logging.Stdout); !ok {
-		t.Errorf("Expected stdout to be *algorithm.Stdout")
-	}
-}
-
-func TestBinaryRun(t *testing.T) {
-	tests := []struct {
-		name          string
-		algoFile      string
-		args          []string
-		expectedError bool
-	}{
-		{
-			name:          "Successful execution",
-			algoFile:      "echo",
-			args:          []string{"Hello, World!"},
-			expectedError: false,
-		},
-		{
-			name:          "Non-existent binary",
-			algoFile:      "non_existent_binary",
-			args:          []string{},
-			expectedError: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-			eventsSvc := new(mocks.Service)
-
-			b := NewAlgorithm(logger, eventsSvc, tt.algoFile, tt.args).(*binary)
-
-			var stdout, stderr bytes.Buffer
-			b.stdout = &stdout
-			b.stderr = &stderr
-
-			err := b.Run()
-
-			if tt.expectedError && err == nil {
-				t.Errorf("Expected an error, but got none")
-			}
-
-			if !tt.expectedError && err != nil {
-				t.Errorf("Unexpected error: %v", err)
-			}
-
-			if !tt.expectedError {
-				if stdout.Len() == 0 {
-					t.Errorf("Expected non-empty stdout")
-				}
-			}
-		})
-	}
-}
@@ -1,178 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package docker
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"io"
-	"log/slog"
-	"os"
-	"path"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/api/types/mount"
-	"github.com/docker/docker/client"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-const (
-	containerName     = "agent_container"
-	datasetsMountPath = "/cocos/datasets"
-	resultsMountPath  = "/cocos/results"
-)
-
-var _ algorithm.Algorithm = (*docker)(nil)
-
-type docker struct {
-	algoFile string
-	logger   *slog.Logger
-	stderr   io.Writer
-	stdout   io.Writer
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string) algorithm.Algorithm {
-	d := &docker{
-		algoFile: algoFile,
-		logger:   logger,
-		stderr:   &logging.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:   &logging.Stdout{Logger: logger},
-	}
-
-	return d
-}
-
-func (d *docker) Run() error {
-	ctx := context.Background()
-
-	// Create a new Docker client.
-	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-	if err != nil {
-		return fmt.Errorf("could not create a new Docker client: %v", err)
-	}
-
-	// Open the Docker image tar file.
-	imageFile, err := os.Open(d.algoFile)
-	if err != nil {
-		return fmt.Errorf("could not open Docker image: %v", err)
-	}
-	defer imageFile.Close()
-
-	// Load the Docker image from the tar file.
-	resp, err := cli.ImageLoad(ctx, imageFile, true)
-	if err != nil {
-		return fmt.Errorf("could not load Docker image from file: %v", err)
-	}
-	defer resp.Body.Close()
-
-	// List the loaded images to get the image ID.
-	images, err := cli.ImageList(ctx, image.ListOptions{})
-	if err != nil {
-		return fmt.Errorf("could not get the Docker image list: %v", err)
-	}
-
-	var imageID string = ""
-	var dockerImageName string = ""
-	for _, image := range images {
-		for _, tag := range image.RepoTags {
-			imageID = image.ID
-			dockerImageName = tag
-			break
-		}
-	}
-
-	if imageID == "" {
-		return fmt.Errorf("could not find image ID")
-	}
-
-	// Create and start the container.
-	respContainer, err := cli.ContainerCreate(ctx, &container.Config{
-		Image:        dockerImageName,
-		Tty:          true,
-		AttachStdout: true,
-		AttachStderr: true,
-	}, &container.HostConfig{
-		Mounts: []mount.Mount{
-			{
-				Type:   mount.TypeBind,
-				Source: path.Join(algorithm.AlgoWorkingDir, algorithm.DatasetsDir),
-				Target: datasetsMountPath,
-			},
-			{
-				Type:   mount.TypeBind,
-				Source: path.Join(algorithm.AlgoWorkingDir, algorithm.ResultsDir),
-				Target: resultsMountPath,
-			},
-		},
-	}, nil, nil, containerName)
-	if err != nil {
-		return fmt.Errorf("could not create a Docker container: %v", err)
-	}
-
-	if err := cli.ContainerStart(ctx, respContainer.ID, container.StartOptions{}); err != nil {
-		return fmt.Errorf("could not start a Docker container: %v", err)
-	}
-
-	stdout, err := cli.ContainerLogs(ctx, respContainer.ID, container.LogsOptions{ShowStdout: true, Follow: true})
-	if err != nil {
-		return fmt.Errorf("could not read stdout from the container: %v", err)
-	}
-	defer stdout.Close()
-
-	go func() {
-		if err := writeToOut(stdout, d.stdout); err != nil {
-			d.logger.Warn(fmt.Sprintf("could not write to stdout: %v", err))
-		}
-	}()
-
-	stderr, err := cli.ContainerLogs(ctx, respContainer.ID, container.LogsOptions{ShowStderr: true, Follow: true})
-	if err != nil {
-		d.logger.Warn(fmt.Sprintf("could not read stderr from the container: %v", err))
-	}
-	defer stderr.Close()
-
-	go func() {
-		if err := writeToOut(stderr, d.stderr); err != nil {
-			d.logger.Warn(fmt.Sprintf("could not write to stderr: %v", err))
-		}
-	}()
-
-	statusCh, errCh := cli.ContainerWait(ctx, respContainer.ID, container.WaitConditionNotRunning)
-	select {
-	case err := <-errCh:
-		if err != nil {
-			return fmt.Errorf("could not wait for a Docker container: %v", err)
-		}
-	case <-statusCh:
-	}
-
-	defer func() {
-		if err = cli.ContainerRemove(ctx, respContainer.ID, container.RemoveOptions{Force: true}); err != nil {
-			d.logger.Warn(fmt.Sprintf("error could not remove container: %v", err))
-		}
-
-		if _, err := cli.ImageRemove(ctx, imageID, image.RemoveOptions{Force: true}); err != nil {
-			d.logger.Warn(fmt.Sprintf("error could not remove image: %v", err))
-		}
-	}()
-
-	return nil
-}
-
-func writeToOut(readCloser io.ReadCloser, ioWriter io.Writer) error {
-	scanner := bufio.NewScanner(readCloser)
-	for scanner.Scan() {
-		if _, err := ioWriter.Write(scanner.Bytes()); err != nil {
-			return fmt.Errorf("error writing to output: %v", err)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		return fmt.Errorf("error reading container logs error: %v", err)
-	}
-
-	return nil
-}
@@ -1,29 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package docker
-
-import (
-	"log/slog"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-)
-
-// TestNewAlgorithm tests the NewAlgorithm function.
-func TestNewAlgorithm(t *testing.T) {
-	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	eventsSvc := new(mocks.Service)
-	algoFile := "/path/to/algo.tar"
-
-	algo := NewAlgorithm(logger, eventsSvc, algoFile)
-
-	d, ok := algo.(*docker)
-	assert.True(t, ok, "NewAlgorithm should return a *docker")
-	assert.Equal(t, algoFile, d.algoFile, "algoFile should be set correctly")
-	assert.NotNil(t, d.logger, "logger should be set")
-	assert.IsType(t, &logging.Stderr{}, d.stderr, "stderr should be of type *algorithm.Stderr")
-	assert.IsType(t, &logging.Stdout{}, d.stdout, "stdout should be of type *algorithm.Stdout")
-}
@@ -1,78 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package logging
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"log/slog"
-
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-var (
-	_ io.Writer = &Stdout{}
-	_ io.Writer = &Stderr{}
-)
-
-const (
-	bufSize       = 1024
-	algorithmRun  = "AlgorithmRun"
-	warningStatus = "Warning"
-)
-
-type Stdout struct {
-	Logger *slog.Logger
-}
-
-// Write implements io.Writer.
-func (s *Stdout) Write(p []byte) (n int, err error) {
-	inBuf := bytes.NewBuffer(p)
-
-	buf := make([]byte, bufSize)
-
-	for {
-		n, err := inBuf.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return len(p) - inBuf.Len(), err
-		}
-
-		s.Logger.Debug(string(buf[:n]))
-	}
-
-	return len(p), nil
-}
-
-type Stderr struct {
-	Logger   *slog.Logger
-	EventSvc events.Service
-}
-
-// Write implements io.Writer.
-func (s *Stderr) Write(p []byte) (n int, err error) {
-	inBuf := bytes.NewBuffer(p)
-
-	buf := make([]byte, bufSize)
-
-	for {
-		n, err := inBuf.Read(buf)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return len(p) - inBuf.Len(), err
-		}
-
-		s.Logger.Error(string(buf[:n]))
-	}
-
-	if err := s.EventSvc.SendEvent(algorithmRun, warningStatus, json.RawMessage{}); err != nil {
-		return len(p), err
-	}
-
-	return len(p), nil
-}
@@ -1,86 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package logging
-
-import (
-	"strings"
-	"testing"
-
-	mglog "github.com/absmach/magistrala/logger"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-	"github.com/ultravioletrs/cocos/pkg/manager"
-)
-
-func TestStdoutWrite(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "Single line",
-			input:    "Hello, World!",
-			expected: []string{"Hello, World!"},
-		},
-		{
-			name:     "Multiple lines",
-			input:    "Line 1\nLine 2\nLine 3",
-			expected: []string{"Line 1\nLine 2\nLine 3"},
-		},
-		{
-			name:     "Long input",
-			input:    strings.Repeat("a", bufSize+100),
-			expected: []string{strings.Repeat("a", bufSize), strings.Repeat("a", 100)},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			stdout := &Stdout{Logger: mglog.NewMock()}
-			n, err := stdout.Write([]byte(tt.input))
-
-			assert.NoError(t, err)
-			assert.Equal(t, len(tt.input), n)
-		})
-	}
-}
-
-func TestStderrWrite(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "Single line",
-			input:    "Error: Something went wrong",
-			expected: []string{"Error: Something went wrong"},
-		},
-		{
-			name:     "Multiple lines",
-			input:    "Error 1\nError 2\nError 3",
-			expected: []string{"Error 1\nError 2\nError 3"},
-		},
-		{
-			name:     "Long input",
-			input:    strings.Repeat("e", bufSize+100),
-			expected: []string{strings.Repeat("e", bufSize), strings.Repeat("e", 100)},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockEventService := mocks.NewService(t)
-			mockEventService.On("SendEvent", "AlgorithmRun", manager.Warning.String(), mock.Anything).Return(nil)
-
-			stderr := &Stderr{Logger: mglog.NewMock(), EventSvc: mockEventService}
-			n, err := stderr.Write([]byte(tt.input))
-
-			assert.NoError(t, err)
-			assert.Equal(t, len(tt.input), n)
-			mockEventService.AssertExpectations(t)
-		})
-	}
-}
@@ -1,105 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package python
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"log/slog"
-	"os"
-	"os/exec"
-	"path/filepath"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events"
-	"google.golang.org/grpc/metadata"
-)
-
-const (
-	PyRuntime    = "python3"
-	PyRuntimeKey = "python_runtime"
-)
-
-func PythonRunTimeToContext(ctx context.Context, runtime string) context.Context {
-	return metadata.AppendToOutgoingContext(ctx, PyRuntimeKey, runtime)
-}
-
-func PythonRunTimeFromContext(ctx context.Context) string {
-	return metadata.ValueFromIncomingContext(ctx, PyRuntimeKey)[0]
-}
-
-var _ algorithm.Algorithm = (*python)(nil)
-
-type python struct {
-	algoFile         string
-	stderr           io.Writer
-	stdout           io.Writer
-	runtime          string
-	requirementsFile string
-	args             []string
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, runtime, requirementsFile, algoFile string, args []string) algorithm.Algorithm {
-	p := &python{
-		algoFile:         algoFile,
-		stderr:           &logging.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:           &logging.Stdout{Logger: logger},
-		requirementsFile: requirementsFile,
-		args:             args,
-	}
-	if runtime != "" {
-		p.runtime = runtime
-	} else {
-		p.runtime = PyRuntime
-	}
-	return p
-}
-
-func (p *python) Run() error {
-	venvPath := "venv"
-	createVenvCmd := exec.Command(p.runtime, "-m", "venv", venvPath)
-	createVenvCmd.Stderr = p.stderr
-	createVenvCmd.Stdout = p.stdout
-	if err := createVenvCmd.Run(); err != nil {
-		return fmt.Errorf("error creating virtual environment: %v", err)
-	}
-
-	pythonPath := filepath.Join(venvPath, "bin", "python")
-
-	updatePipCmd := exec.Command(pythonPath, "-m", "pip", "install", "--upgrade", "pip")
-	updatePipCmd.Stderr = p.stderr
-	updatePipCmd.Stdout = p.stdout
-	if err := updatePipCmd.Run(); err != nil {
-		return fmt.Errorf("error updating pip: %v", err)
-	}
-
-	if p.requirementsFile != "" {
-		rcmd := exec.Command(pythonPath, "-m", "pip", "install", "-r", p.requirementsFile)
-		rcmd.Stderr = p.stderr
-		rcmd.Stdout = p.stdout
-		if err := rcmd.Run(); err != nil {
-			return fmt.Errorf("error installing requirements: %v", err)
-		}
-	}
-
-	args := append([]string{p.algoFile}, p.args...)
-	cmd := exec.Command(pythonPath, args...)
-	cmd.Stderr = p.stderr
-	cmd.Stdout = p.stdout
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("error starting algorithm: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("algorithm execution error: %v", err)
-	}
-
-	if err := os.RemoveAll(venvPath); err != nil {
-		return fmt.Errorf("error removing virtual environment: %v", err)
-	}
-
-	return nil
-}
@@ -1,148 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package python
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-	"google.golang.org/grpc/metadata"
-)
-
-const runtime = "python3"
-
-func TestPythonRunTimeToContext(t *testing.T) {
-	ctx := context.Background()
-	newCtx := PythonRunTimeToContext(ctx, runtime)
-
-	md, ok := metadata.FromOutgoingContext(newCtx)
-	if !ok {
-		t.Fatal("Expected metadata in context")
-	}
-
-	values := md.Get(PyRuntimeKey)
-	if len(values) != 1 || values[0] != runtime {
-		t.Errorf("Expected runtime %s, got %v", runtime, values)
-	}
-}
-
-func TestPythonRunTimeFromContext(t *testing.T) {
-	ctx := metadata.NewIncomingContext(context.Background(), metadata.Pairs(PyRuntimeKey, runtime))
-
-	got := PythonRunTimeFromContext(ctx)
-	if got != runtime {
-		t.Errorf("Expected runtime %s, got %s", runtime, got)
-	}
-}
-
-func TestNewAlgorithm(t *testing.T) {
-	logger := &slog.Logger{}
-	eventsSvc := new(mocks.Service)
-	requirementsFile := "requirements.txt"
-	algoFile := "algorithm.py"
-	args := []string{"--arg1", "value1"}
-
-	algo := NewAlgorithm(logger, eventsSvc, runtime, requirementsFile, algoFile, args)
-
-	p, ok := algo.(*python)
-	if !ok {
-		t.Fatal("Expected *python type")
-	}
-
-	if p.runtime != runtime {
-		t.Errorf("Expected runtime %s, got %s", runtime, p.runtime)
-	}
-	if p.requirementsFile != requirementsFile {
-		t.Errorf("Expected requirementsFile %s, got %s", requirementsFile, p.requirementsFile)
-	}
-	if p.algoFile != algoFile {
-		t.Errorf("Expected algoFile %s, got %s", algoFile, p.algoFile)
-	}
-	if len(p.args) != len(args) {
-		t.Errorf("Expected %d args, got %d", len(args), len(p.args))
-	}
-}
-
-func TestRun(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "python-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	scriptContent := []byte("print('Hello, World!')")
-	scriptPath := filepath.Join(tmpDir, "test_script.py")
-	if err := os.WriteFile(scriptPath, scriptContent, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	eventsSvc := new(mocks.Service)
-
-	var stdout, stderr bytes.Buffer
-
-	algo := &python{
-		algoFile: scriptPath,
-		stderr:   io.MultiWriter(&stderr, &logging.Stderr{Logger: slog.Default(), EventSvc: eventsSvc}),
-		stdout:   io.MultiWriter(&stdout, &logging.Stdout{Logger: slog.Default()}),
-		runtime:  "python3",
-	}
-
-	err = algo.Run()
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-
-	expectedOutput := "Hello, World!\n"
-	if !strings.Contains(stdout.String(), expectedOutput) {
-		t.Errorf("Expected output to contain %q, got %q", expectedOutput, stdout.String())
-	}
-}
-
-func TestRunWithRequirements(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "python-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	scriptContent := []byte("import requests\nprint(requests.__version__)")
-	scriptPath := filepath.Join(tmpDir, "test_script.py")
-	if err := os.WriteFile(scriptPath, scriptContent, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	requirementsContent := []byte("requests==2.26.0")
-	requirementsPath := filepath.Join(tmpDir, "requirements.txt")
-	if err := os.WriteFile(requirementsPath, requirementsContent, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	eventsSvc := new(mocks.Service)
-
-	var stdout, stderr bytes.Buffer
-
-	algo := &python{
-		algoFile:         scriptPath,
-		requirementsFile: requirementsPath,
-		stderr:           io.MultiWriter(&stderr, &logging.Stderr{Logger: slog.Default(), EventSvc: eventsSvc}),
-		stdout:           io.MultiWriter(&stdout, &logging.Stdout{Logger: slog.Default()}),
-		runtime:          "python3",
-	}
-
-	err = algo.Run()
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-
-	if !strings.Contains(stdout.String(), "2.26.0") {
-		t.Errorf("Expected output to contain requests version 2.26.0, got %q", stdout.String())
-	}
-}
@@ -1,82 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package algorithm_test
-
-import (
-	"os"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/internal"
-)
-
-func TestZipDirectory(t *testing.T) {
-	cases := []struct {
-		name        string
-		directories []string
-		files       []string
-		expected    []string
-	}{
-		{
-			name:        "empty directory",
-			directories: []string{"testdata"},
-		},
-		{
-			name:  "single file",
-			files: []string{"file1.txt"},
-		},
-		{
-			name:        "directory with single file",
-			directories: []string{"testdata"},
-			expected:    []string{"testdata/file1.txt"},
-		},
-		{
-			name:        "directory with multiple files",
-			directories: []string{"testdata"},
-			expected: []string{
-				"testdata/file1.txt",
-				"testdata/file2.txt",
-				"testdata/file3.txt",
-			},
-		},
-		{
-			name:        "nested directories",
-			directories: []string{"testdata", "testdata/nested"},
-			expected: []string{
-				"testdata/nested/file1.txt",
-				"testdata/nested/file2.txt",
-				"testdata/nested/file3.txt",
-			},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if err := os.Mkdir(algorithm.ResultsDir, 0o755); err != nil {
-				t.Fatalf("error creating results directory: %s", err.Error())
-			}
-			defer func() {
-				if err := os.RemoveAll(algorithm.ResultsDir); err != nil {
-					t.Fatalf("error removing results directory and its contents: %s", err.Error())
-				}
-			}()
-
-			for _, dir := range tc.directories {
-				if dir != "" {
-					if err := os.Mkdir(algorithm.ResultsDir+"/"+dir, 0o755); err != nil {
-						t.Fatalf("error creating test directory: %s", err.Error())
-					}
-				}
-			}
-			for _, file := range tc.files {
-				if _, err := os.Create(algorithm.ResultsDir + "/" + file); err != nil {
-					t.Fatalf("error creating test file: %s", err.Error())
-				}
-			}
-
-			if _, err := internal.ZipDirectoryToMemory(algorithm.ResultsDir); err != nil {
-				t.Errorf("ZipDirectory() error = %v", err)
-			}
-		})
-	}
-}
@@ -1,54 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package wasm
-
-import (
-	"fmt"
-	"io"
-	"log/slog"
-	"os/exec"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events"
-)
-
-const wasmRuntime = "wasmedge"
-
-var mapDirOption = []string{"--dir", ".:" + algorithm.ResultsDir}
-
-var _ algorithm.Algorithm = (*wasm)(nil)
-
-type wasm struct {
-	algoFile string
-	stderr   io.Writer
-	stdout   io.Writer
-	args     []string
-}
-
-func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string, args []string) algorithm.Algorithm {
-	return &wasm{
-		algoFile: algoFile,
-		stderr:   &logging.Stderr{Logger: logger, EventSvc: eventsSvc},
-		stdout:   &logging.Stdout{Logger: logger},
-		args:     args,
-	}
-}
-
-func (w *wasm) Run() error {
-	args := append(mapDirOption, w.algoFile)
-	args = append(args, w.args...)
-	cmd := exec.Command(wasmRuntime, args...)
-	cmd.Stderr = w.stderr
-	cmd.Stdout = w.stdout
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("error starting algorithm: %v", err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("algorithm execution error: %v", err)
-	}
-
-	return nil
-}
@@ -1,89 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package wasm
-
-import (
-	"log/slog"
-	"os"
-	"os/exec"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-)
-
-func TestNewAlgorithm(t *testing.T) {
-	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	eventsSvc := new(mocks.Service)
-	algoFile := "test.wasm"
-	args := []string{"arg1", "arg2"}
-
-	algo := NewAlgorithm(logger, eventsSvc, algoFile, args)
-
-	w, ok := algo.(*wasm)
-	if !ok {
-		t.Fatalf("NewAlgorithm did not return a *wasm")
-	}
-
-	if w.algoFile != algoFile {
-		t.Errorf("Expected algoFile to be %s, got %s", algoFile, w.algoFile)
-	}
-
-	if len(w.args) != len(args) {
-		t.Errorf("Expected %d args, got %d", len(args), len(w.args))
-	}
-
-	_, ok = w.stderr.(*logging.Stderr)
-	if !ok {
-		t.Errorf("Expected stderr to be *algorithm.Stderr")
-	}
-
-	_, ok = w.stdout.(*logging.Stdout)
-	if !ok {
-		t.Errorf("Expected stdout to be *algorithm.Stdout")
-	}
-}
-
-func TestRunError(t *testing.T) {
-	// Mock exec.Command to return an error
-	execCommand = mockExecCommandError
-	defer func() { execCommand = exec.Command }()
-
-	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	eventsSvc := new(mocks.Service)
-	algoFile := "test.wasm"
-	args := []string{"arg1", "arg2"}
-
-	w := NewAlgorithm(logger, eventsSvc, algoFile, args).(*wasm)
-
-	err := w.Run()
-	if err == nil {
-		t.Errorf("Run() should have returned an error")
-	}
-}
-
-func mockExecCommand(command string, args ...string) *exec.Cmd {
-	cs := []string{"-test.run=TestHelperProcess", "--", command}
-	cs = append(cs, args...)
-	cmd := exec.Command(os.Args[0], cs...)
-	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}
-	return cmd
-}
-
-func mockExecCommandError(command string, args ...string) *exec.Cmd {
-	cmd := mockExecCommand(command, args...)
-	cmd.Env = append(cmd.Env, "GO_WANT_HELPER_PROCESS_ERROR=1")
-	return cmd
-}
-
-func TestHelperProcess(t *testing.T) {
-	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
-		return
-	}
-	if os.Getenv("GO_WANT_HELPER_PROCESS_ERROR") == "1" {
-		os.Exit(1)
-	}
-	os.Exit(0)
-}
-
-var execCommand = exec.Command
@@ -0,0 +1,218 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package grpc
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/go-kit/kit/endpoint"
+	kitgrpc "github.com/go-kit/kit/transport/grpc"
+	"github.com/ultravioletrs/cocos/agent"
+	"google.golang.org/grpc"
+)
+
+const svcName = "agent.AgentService"
+
+type grpcClient struct {
+	algo        endpoint.Endpoint
+	data        endpoint.Endpoint
+	result      endpoint.Endpoint
+	attestation endpoint.Endpoint
+	timeout     time.Duration
+}
+
+// NewClient returns new gRPC client instance.
+func NewClient(conn *grpc.ClientConn, timeout time.Duration) agent.AgentServiceClient {
+	return &grpcClient{
+		algo: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Algo",
+			encodeAlgoRequest,
+			decodeAlgoResponse,
+			agent.AlgoResponse{},
+		).Endpoint(),
+		data: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Data",
+			encodeDataRequest,
+			decodeDataResponse,
+			agent.DataResponse{},
+		).Endpoint(),
+		result: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Result",
+			encodeResultRequest,
+			decodeResultResponse,
+			agent.ResultResponse{},
+		).Endpoint(),
+		attestation: kitgrpc.NewClient(
+			conn,
+			svcName,
+			"Attestation",
+			encodeAttestationRequest,
+			decodeAttestationResponse,
+			agent.AttestationResponse{},
+		).Endpoint(),
+		timeout: timeout,
+	}
+}
+
+// encodeAlgoRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain algoReq to a gRPC request.
+func encodeAlgoRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*algoReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+
+	return &agent.AlgoRequest{
+		Algorithm: req.Algorithm,
+		Provider:  req.Provider,
+		Id:        req.Id,
+	}, nil
+}
+
+// decodeAlgoResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC AlgoResponse to a user-domain response.
+func decodeAlgoResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	_, ok := grpcResponse.(*agent.AlgoResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return algoRes{}, nil
+}
+
+// encodeDataRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain dataReq to a gRPC request.
+func encodeDataRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*dataReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+
+	return &agent.DataRequest{
+		Dataset:  req.Dataset,
+		Provider: req.Provider,
+		Id:       req.Id,
+	}, nil
+}
+
+// decodeDataResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC DataResponse to a user-domain response.
+func decodeDataResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	_, ok := grpcResponse.(*agent.DataResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return dataRes{}, nil
+}
+
+// encodeResultRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain resultReq to a gRPC request.
+func encodeResultRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*resultReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+
+	return &agent.ResultRequest{
+		Consumer: req.Consumer,
+	}, nil
+}
+
+// decodeResultResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC ResultResponse to a user-domain response.
+func decodeResultResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	response, ok := grpcResponse.(*agent.ResultResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return resultRes{
+		File: response.File,
+	}, nil
+}
+
+// encodeAttestationRequest is a transport/grpc.EncodeRequestFunc that
+// converts a user-domain attestationReq to a gRPC request.
+func encodeAttestationRequest(_ context.Context, request interface{}) (interface{}, error) {
+	req, ok := request.(*attestationReq)
+	if !ok {
+		return nil, fmt.Errorf("invalid request type: %T", request)
+	}
+	return &agent.AttestationRequest{ReportData: req.ReportData[:]}, nil
+}
+
+// decodeAttestationResponse is a transport/grpc.DecodeResponseFunc that
+// converts a gRPC AttestationResponse to a user-domain response.
+func decodeAttestationResponse(_ context.Context, grpcResponse interface{}) (interface{}, error) {
+	response, ok := grpcResponse.(*agent.AttestationResponse)
+	if !ok {
+		return nil, fmt.Errorf("invalid response type: %T", grpcResponse)
+	}
+
+	return attestationRes{
+		File: response.File,
+	}, nil
+}
+
+// Algo implements the Algo method of the agent.AgentServiceClient interface.
+func (c grpcClient) Algo(ctx context.Context, request *agent.AlgoRequest, _ ...grpc.CallOption) (*agent.AlgoResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	_, err := c.algo(ctx, &algoReq{Algorithm: request.Algorithm, Provider: request.Provider, Id: request.Id})
+	if err != nil {
+		return nil, err
+	}
+
+	return &agent.AlgoResponse{}, nil
+}
+
+// Data implements the Data method of the agent.AgentServiceClient interface.
+func (c grpcClient) Data(ctx context.Context, request *agent.DataRequest, _ ...grpc.CallOption) (*agent.DataResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	_, err := c.data(ctx, &dataReq{Dataset: request.Dataset, Provider: request.Provider, Id: request.Id})
+	if err != nil {
+		return nil, err
+	}
+
+	return &agent.DataResponse{}, nil
+}
+
+// Result implements the Result method of the agent.AgentServiceClient interface.
+func (c grpcClient) Result(ctx context.Context, request *agent.ResultRequest, _ ...grpc.CallOption) (*agent.ResultResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	res, err := c.result(ctx, &resultReq{Consumer: request.Consumer})
+	if err != nil {
+		return nil, err
+	}
+
+	resultRes := res.(resultRes)
+	return &agent.ResultResponse{File: resultRes.File}, nil
+}
+
+// Result implements the Result method of the agent.AgentServiceClient interface.
+func (c grpcClient) Attestation(ctx context.Context, request *agent.AttestationRequest, _ ...grpc.CallOption) (*agent.AttestationResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, c.timeout)
+	defer cancel()
+
+	res, err := c.attestation(ctx, &attestationReq{ReportData: [agent.ReportDataSize]byte(request.ReportData)})
+	if err != nil {
+		return nil, err
+	}
+
+	attestationRes := res.(attestationRes)
+	return &agent.AttestationResponse{File: attestationRes.File}, nil
+}
@@ -17,7 +17,7 @@ func algoEndpoint(svc agent.Service) endpoint.Endpoint {
 			return algoRes{}, err
 		}

-		algo := agent.Algorithm{Algorithm: req.Algorithm, Requirements: req.Requirements}
+		algo := agent.Algorithm{Algorithm: req.Algorithm, Provider: req.Provider, ID: req.Id}

 		err := svc.Algo(ctx, algo)
 		if err != nil {
@@ -36,7 +36,7 @@ func dataEndpoint(svc agent.Service) endpoint.Endpoint {
 			return dataRes{}, err
 		}

-		dataset := agent.Dataset{Dataset: req.Dataset, Filename: req.Filename}
+		dataset := agent.Dataset{Dataset: req.Dataset, Provider: req.Provider, ID: req.Id}

 		err := svc.Data(ctx, dataset)
 		if err != nil {
@@ -54,7 +54,7 @@ func resultEndpoint(svc agent.Service) endpoint.Endpoint {
 		if err := req.validate(); err != nil {
 			return resultRes{}, err
 		}
-		file, err := svc.Result(ctx)
+		file, err := svc.Result(ctx, req.Consumer)
 		if err != nil {
 			return resultRes{}, err
 		}
@@ -1,173 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package grpc
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/mocks"
-	"golang.org/x/crypto/sha3"
-)
-
-const svcErr = "Service Error"
-
-func TestAlgoEndpoint(t *testing.T) {
-	svc := new(mocks.Service)
-	tests := []struct {
-		name        string
-		req         algoReq
-		expectedErr bool
-	}{
-		{
-			name: "Success",
-			req:  algoReq{Algorithm: []byte("algorithm")},
-		},
-		{
-			name:        "Validation Error",
-			req:         algoReq{},
-			expectedErr: true,
-		},
-		{
-			name:        "Service Error",
-			req:         algoReq{Algorithm: []byte("algorithm")},
-			expectedErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.name == svcErr {
-				svc.On("Algo", context.Background(), agent.Algorithm{Algorithm: tt.req.Algorithm}).Return(errors.New("")).Once()
-			} else {
-				svc.On("Algo", context.Background(), agent.Algorithm{Algorithm: tt.req.Algorithm}).Return(nil).Once()
-			}
-			endpoint := algoEndpoint(svc)
-			_, err := endpoint(context.Background(), tt.req)
-			if (err != nil) != tt.expectedErr {
-				t.Errorf("algoEndpoint() error = %v, expectedErr %v", err, tt.expectedErr)
-			}
-		})
-	}
-}
-
-func TestDataEndpoint(t *testing.T) {
-	svc := new(mocks.Service)
-	tests := []struct {
-		name        string
-		req         dataReq
-		expectedErr bool
-	}{
-		{
-			name: "Success",
-			req:  dataReq{Dataset: []byte("dataset")},
-		},
-		{
-			name:        "Validation Error",
-			req:         dataReq{},
-			expectedErr: true,
-		},
-		{
-			name:        "Service Error",
-			req:         dataReq{Dataset: []byte("dataset")},
-			expectedErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.name == svcErr {
-				svc.On("Data", context.Background(), agent.Dataset{Dataset: tt.req.Dataset}).Return(errors.New("")).Once()
-			} else {
-				svc.On("Data", context.Background(), agent.Dataset{Dataset: tt.req.Dataset}).Return(nil).Once()
-			}
-			endpoint := dataEndpoint(svc)
-			_, err := endpoint(context.Background(), tt.req)
-			if (err != nil) != tt.expectedErr {
-				t.Errorf("dataEndpoint() error = %v, expectedErr %v", err, tt.expectedErr)
-			}
-		})
-	}
-}
-
-func TestResultEndpoint(t *testing.T) {
-	svc := new(mocks.Service)
-	tests := []struct {
-		name        string
-		req         resultReq
-		expectedErr bool
-	}{
-		{
-			name: "Success",
-			req:  resultReq{},
-		},
-		{
-			name:        "Service Error",
-			req:         resultReq{},
-			expectedErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.name == svcErr {
-				svc.On("Result", context.Background()).Return([]byte{}, errors.New("")).Once()
-			} else {
-				svc.On("Result", context.Background()).Return([]byte{}, nil).Once()
-			}
-			endpoint := resultEndpoint(svc)
-			res, err := endpoint(context.Background(), tt.req)
-			if (err != nil) != tt.expectedErr {
-				t.Errorf("resultEndpoint() error = %v, expectedErr %v", err, tt.expectedErr)
-			}
-			if err == nil {
-				_, ok := res.(resultRes)
-				if !ok {
-					t.Errorf("resultEndpoint() returned unexpected type %T", res)
-				}
-			}
-		})
-	}
-}
-
-func TestAttestationEndpoint(t *testing.T) {
-	svc := new(mocks.Service)
-	tests := []struct {
-		name        string
-		req         attestationReq
-		expectedErr bool
-	}{
-		{
-			name: "Success",
-			req:  attestationReq{ReportData: sha3.Sum512([]byte("report data"))},
-		},
-		{
-			name:        "Service Error",
-			req:         attestationReq{ReportData: sha3.Sum512([]byte("report data"))},
-			expectedErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.name == svcErr {
-				svc.On("Attestation", context.Background(), tt.req.ReportData).Return([]byte{}, errors.New("")).Once()
-			} else {
-				svc.On("Attestation", context.Background(), tt.req.ReportData).Return([]byte{}, nil).Once()
-			}
-			endpoint := attestationEndpoint(svc)
-			res, err := endpoint(context.Background(), tt.req)
-			if (err != nil) != tt.expectedErr {
-				t.Errorf("attestationEndpoint() error = %v, expectedErr %v", err, tt.expectedErr)
-			}
-			if err == nil {
-				_, ok := res.(attestationRes)
-				if !ok {
-					t.Errorf("attestationEndpoint() returned unexpected type %T", res)
-				}
-			}
-		})
-	}
-}
@@ -1,74 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package grpc
-
-import (
-	"context"
-
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/auth"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-type authInterceptor struct {
-	auth auth.Authenticator
-}
-
-type wrappedServerStream struct {
-	grpc.ServerStream
-	ctx context.Context
-}
-
-func (s *wrappedServerStream) Context() context.Context {
-	return s.ctx
-}
-
-func NewAuthInterceptor(authSvc auth.Authenticator) (grpc.UnaryServerInterceptor, grpc.StreamServerInterceptor) {
-	ai := &authInterceptor{auth: authSvc}
-	return ai.AuthUnaryInterceptor(), ai.AuthStreamInterceptor()
-}
-
-func (s *authInterceptor) AuthStreamInterceptor() grpc.StreamServerInterceptor {
-	return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
-		switch info.FullMethod {
-		case agent.AgentService_Algo_FullMethodName:
-			if _, err := s.auth.AuthenticateUser(stream.Context(), auth.AlgorithmProviderRole); err != nil {
-				return status.Errorf(codes.Unauthenticated, "%v", err.Error())
-			}
-			return handler(srv, stream)
-		case agent.AgentService_Data_FullMethodName:
-			ctx, err := s.auth.AuthenticateUser(stream.Context(), auth.DataProviderRole)
-			if err != nil {
-				return status.Errorf(codes.Unauthenticated, "%s", err.Error())
-			}
-			wrapped := &wrappedServerStream{ServerStream: stream, ctx: ctx}
-			return handler(srv, wrapped)
-		case agent.AgentService_Result_FullMethodName:
-			ctx, err := s.auth.AuthenticateUser(stream.Context(), auth.ConsumerRole)
-			if err != nil {
-				return status.Errorf(codes.Unauthenticated, "%v", err.Error())
-			}
-			wrapped := &wrappedServerStream{ServerStream: stream, ctx: ctx}
-			return handler(srv, wrapped)
-		default:
-			return handler(srv, stream)
-		}
-	}
-}
-
-func (s *authInterceptor) AuthUnaryInterceptor() grpc.UnaryServerInterceptor {
-	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
-		switch info.FullMethod {
-		case agent.AgentService_Result_FullMethodName:
-			ctx, err := s.auth.AuthenticateUser(ctx, auth.ConsumerRole)
-			if err != nil {
-				return nil, status.Errorf(codes.Unauthenticated, "%v", err.Error())
-			}
-			return handler(ctx, req)
-		default:
-			return handler(ctx, req)
-		}
-	}
-}
@@ -1,152 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package grpc
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/auth"
-	"github.com/ultravioletrs/cocos/agent/auth/mocks"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-)
-
-func TestAuthUnaryInterceptor(t *testing.T) {
-	authmock := new(mocks.Authenticator)
-	tests := []struct {
-		name       string
-		authorized bool
-		method     string
-		role       auth.UserRole
-		wantErr    bool
-	}{
-		{
-			name:       "authorized result method",
-			authorized: true,
-			method:     agent.AgentService_Result_FullMethodName,
-			role:       auth.ConsumerRole,
-			wantErr:    false,
-		},
-		{
-			name:       "unauthorized result method",
-			authorized: false,
-			method:     agent.AgentService_Result_FullMethodName,
-			role:       auth.ConsumerRole,
-			wantErr:    true,
-		},
-		{
-			name:       "other method",
-			authorized: false,
-			method:     "OtherMethod",
-			role:       auth.ConsumerRole,
-			wantErr:    false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch tt.authorized {
-			case true:
-				mockCall := authmock.On("AuthenticateUser", context.Background(), tt.role).Return(context.Background(), nil)
-				mockCall.Once()
-			case false:
-				mockCall := authmock.On("AuthenticateUser", context.Background(), tt.role).Return(context.Background(), auth.ErrMissingMetadata)
-				mockCall.Once()
-			}
-			unaryInt, _ := NewAuthInterceptor(authmock)
-
-			_, err := unaryInt(context.Background(), nil, &grpc.UnaryServerInfo{FullMethod: tt.method}, func(ctx context.Context, req interface{}) (interface{}, error) {
-				return nil, nil
-			})
-
-			if tt.wantErr && err == nil {
-				t.Errorf("expected error, got none")
-			} else if !tt.wantErr && err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-func TestAuthStreamInterceptor(t *testing.T) {
-	authmock := new(mocks.Authenticator)
-	tests := []struct {
-		name       string
-		authorized bool
-		method     string
-		role       auth.UserRole
-		wantErr    bool
-	}{
-		{
-			name:       "authorized algo method",
-			authorized: true,
-			method:     agent.AgentService_Algo_FullMethodName,
-			role:       auth.AlgorithmProviderRole,
-			wantErr:    false,
-		},
-		{
-			name:       "unauthorized algo method",
-			authorized: false,
-			method:     agent.AgentService_Algo_FullMethodName,
-			role:       auth.AlgorithmProviderRole,
-			wantErr:    true,
-		},
-		{
-			name:       "authorized data method",
-			authorized: true,
-			method:     agent.AgentService_Data_FullMethodName,
-			role:       auth.DataProviderRole,
-			wantErr:    false,
-		},
-		{
-			name:       "unauthorized data method",
-			authorized: false,
-			method:     agent.AgentService_Data_FullMethodName,
-			role:       auth.DataProviderRole,
-			wantErr:    true,
-		},
-		{
-			name:       "other method",
-			authorized: false,
-			method:     "OtherMethod",
-			role:       auth.DataProviderRole,
-			wantErr:    false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch tt.authorized {
-			case true:
-				mockCall := authmock.On("AuthenticateUser", mock.Anything, tt.role).Return(context.Background(), nil)
-				mockCall.Once()
-			case false:
-				mockCall := authmock.On("AuthenticateUser", mock.Anything, tt.role).Return(context.Background(), auth.ErrMissingMetadata)
-				mockCall.Once()
-			}
-			_, streamInt := NewAuthInterceptor(authmock)
-
-			err := streamInt(nil, &mockServerStream{ctx: metadata.NewIncomingContext(context.Background(), metadata.Pairs())}, &grpc.StreamServerInfo{FullMethod: tt.method}, func(srv interface{}, stream grpc.ServerStream) error {
-				return nil
-			})
-
-			if tt.wantErr && err == nil {
-				t.Errorf("expected error, got none")
-			} else if !tt.wantErr && err != nil {
-				t.Errorf("unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-type mockServerStream struct {
-	grpc.ServerStream
-	ctx context.Context
-}
-
-func (m *mockServerStream) Context() context.Context {
-	return m.ctx
-}
@@ -7,30 +7,46 @@ import (
 )

 type algoReq struct {
-	Algorithm    []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
-	Requirements []byte
+	Algorithm []byte `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
+	Provider  string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id        string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }

 func (req algoReq) validate() error {
 	if len(req.Algorithm) == 0 {
 		return errors.New("algorithm binary is required")
 	}
+	if req.Id == "" {
+		return errors.New("malformed entity")
+	}
+	if req.Provider == "" {
+		return errors.New("malformed entity")
+	}
 	return nil
 }

 type dataReq struct {
 	Dataset  []byte `protobuf:"bytes,1,opt,name=dataset,proto3" json:"dataset,omitempty"`
-	Filename string
+	Provider string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
+	Id       string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
 }

 func (req dataReq) validate() error {
 	if len(req.Dataset) == 0 {
 		return errors.New("dataset CSV file is required")
 	}
+	if req.Id == "" {
+		return errors.New("malformed entity")
+	}
+	if req.Provider == "" {
+		return errors.New("malformed entity")
+	}
 	return nil
 }

-type resultReq struct{}
+type resultReq struct {
+	Consumer string `protobuf:"bytes,1,opt,name=consumer,proto3" json:"consumer,omitempty"`
+}

 func (req resultReq) validate() error {
 	// No request parameters to validate, so no validation logic needed
@@ -3,26 +3,13 @@
 package grpc

 import (
-	"bytes"
 	"context"
 	"errors"
-	"fmt"
-	"io"

 	"github.com/go-kit/kit/transport/grpc"
 	"github.com/ultravioletrs/cocos/agent"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
 )

-const (
-	bufferSize  = 1024 * 1024
-	FileSizeKey = "file-size"
-)
-
-var _ agent.AgentServiceServer = (*grpcServer)(nil)
-
 type grpcServer struct {
 	algo        grpc.Handler
 	data        grpc.Handler
@@ -61,8 +48,9 @@ func decodeAlgoRequest(_ context.Context, grpcReq interface{}) (interface{}, err
 	req := grpcReq.(*agent.AlgoRequest)

 	return algoReq{
-		Algorithm:    req.Algorithm,
-		Requirements: req.Requirements,
+		Algorithm: req.Algorithm,
+		Provider:  req.Provider,
+		Id:        req.Id,
 	}, nil
 }

@@ -75,7 +63,8 @@ func decodeDataRequest(_ context.Context, grpcReq interface{}) (interface{}, err

 	return dataReq{
 		Dataset:  req.Dataset,
-		Filename: req.Filename,
+		Provider: req.Provider,
+		Id:       req.Id,
 	}, nil
 }

@@ -84,7 +73,8 @@ func encodeDataResponse(_ context.Context, response interface{}) (interface{}, e
 }

 func decodeResultRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	return resultReq{}, nil
+	req := grpcReq.(*agent.ResultRequest)
+	return resultReq{Consumer: req.Consumer}, nil
 }

 func encodeResultResponse(_ context.Context, response interface{}) (interface{}, error) {
@@ -109,111 +99,38 @@ func encodeAttestationResponse(_ context.Context, response interface{}) (interfa
 	}, nil
 }

-// Algo implements agent.AgentServiceServer.
-func (s *grpcServer) Algo(stream agent.AgentService_AlgoServer) error {
-	var algoFile, reqFile []byte
-	for {
-		algoChunk, err := stream.Recv()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-		algoFile = append(algoFile, algoChunk.Algorithm...)
-		reqFile = append(reqFile, algoChunk.Requirements...)
-	}
-	_, res, err := s.algo.ServeGRPC(stream.Context(), &agent.AlgoRequest{Algorithm: algoFile, Requirements: reqFile})
+func (s *grpcServer) Algo(ctx context.Context, req *agent.AlgoRequest) (*agent.AlgoResponse, error) {
+	_, res, err := s.algo.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	ar := res.(*agent.AlgoResponse)
-	return stream.SendAndClose(ar)
+	return ar, nil
 }

-// Data implements agent.AgentServiceServer.
-func (s *grpcServer) Data(stream agent.AgentService_DataServer) error {
-	var dataFile []byte
-	var filename string
-	for {
-		dataChunk, err := stream.Recv()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-		dataFile = append(dataFile, dataChunk.Dataset...)
-		filename = dataChunk.Filename
-	}
-	_, res, err := s.data.ServeGRPC(stream.Context(), &agent.DataRequest{Dataset: dataFile, Filename: filename})
+func (s *grpcServer) Data(ctx context.Context, req *agent.DataRequest) (*agent.DataResponse, error) {
+	_, res, err := s.data.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	ar := res.(*agent.DataResponse)
-	return stream.SendAndClose(ar)
+	dr := res.(*agent.DataResponse)
+	return dr, nil
 }

-func (s *grpcServer) Result(req *agent.ResultRequest, stream agent.AgentService_ResultServer) error {
-	_, res, err := s.result.ServeGRPC(stream.Context(), req)
+func (s *grpcServer) Result(ctx context.Context, req *agent.ResultRequest) (*agent.ResultResponse, error) {
+	_, res, err := s.result.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	rr := res.(*agent.ResultResponse)
-
-	if err := stream.SetHeader(metadata.New(map[string]string{FileSizeKey: fmt.Sprint(len(rr.File))})); err != nil {
-		return status.Error(codes.Internal, err.Error())
-	}
-
-	resultBuffer := bytes.NewBuffer(rr.File)
-
-	buf := make([]byte, bufferSize)
-
-	for {
-		n, err := resultBuffer.Read(buf)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-
-		if err := stream.Send(&agent.ResultResponse{File: buf[:n]}); err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-	}
-
-	return nil
+	return rr, nil
 }

-func (s *grpcServer) Attestation(req *agent.AttestationRequest, stream agent.AgentService_AttestationServer) error {
-	_, res, err := s.attestation.ServeGRPC(stream.Context(), req)
+func (s *grpcServer) Attestation(ctx context.Context, req *agent.AttestationRequest) (*agent.AttestationResponse, error) {
+	_, res, err := s.attestation.ServeGRPC(ctx, req)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	rr := res.(*agent.AttestationResponse)
-
-	if err := stream.SetHeader(metadata.New(map[string]string{FileSizeKey: fmt.Sprint(len(rr.File))})); err != nil {
-		return status.Error(codes.Internal, err.Error())
-	}
-
-	attestationBuffer := bytes.NewBuffer(rr.File)
-
-	buf := make([]byte, bufferSize)
-
-	for {
-		n, err := attestationBuffer.Read(buf)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-
-		if err := stream.Send(&agent.AttestationResponse{File: buf[:n]}); err != nil {
-			return status.Error(codes.Internal, err.Error())
-		}
-	}
-
-	return nil
+	return rr, nil
 }
@@ -1,213 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package grpc
-
-import (
-	"context"
-	"io"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/mocks"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
-)
-
-type MockAgentService_AlgoServer struct {
-	grpc.ServerStream
-	mock.Mock
-	ctx context.Context
-}
-
-func (m *MockAgentService_AlgoServer) Context() context.Context {
-	return m.ctx
-}
-
-func (m *MockAgentService_AlgoServer) Recv() (*agent.AlgoRequest, error) {
-	args := m.Called()
-	return args.Get(0).(*agent.AlgoRequest), args.Error(1)
-}
-
-func (m *MockAgentService_AlgoServer) SendAndClose(resp *agent.AlgoResponse) error {
-	args := m.Called(resp)
-	return args.Error(0)
-}
-
-type MockAgentService_DataServer struct {
-	grpc.ServerStream
-	mock.Mock
-	ctx context.Context
-}
-
-func (m *MockAgentService_DataServer) Context() context.Context {
-	return m.ctx
-}
-
-func (m *MockAgentService_DataServer) Recv() (*agent.DataRequest, error) {
-	args := m.Called()
-	return args.Get(0).(*agent.DataRequest), args.Error(1)
-}
-
-func (m *MockAgentService_DataServer) SendAndClose(resp *agent.DataResponse) error {
-	args := m.Called(resp)
-	return args.Error(0)
-}
-
-type MockAgentService_ResultServer struct {
-	grpc.ServerStream
-	mock.Mock
-	ctx context.Context
-}
-
-func (m *MockAgentService_ResultServer) Context() context.Context {
-	return m.ctx
-}
-
-func (m *MockAgentService_ResultServer) SetHeader(metadata.MD) error {
-	return nil
-}
-
-func (m *MockAgentService_ResultServer) Send(resp *agent.ResultResponse) error {
-	args := m.Called(resp)
-	return args.Error(0)
-}
-
-type MockAgentService_AttestationServer struct {
-	grpc.ServerStream
-	mock.Mock
-	ctx context.Context
-}
-
-func (m *MockAgentService_AttestationServer) Context() context.Context {
-	return m.ctx
-}
-
-func (m *MockAgentService_AttestationServer) Send(resp *agent.AttestationResponse) error {
-	args := m.Called(resp)
-	return args.Error(0)
-}
-
-func (m *MockAgentService_AttestationServer) SetHeader(metadata.MD) error {
-	return nil
-}
-
-func TestAlgo(t *testing.T) {
-	mockService := new(mocks.Service)
-	server := NewServer(mockService)
-
-	mockStream := &MockAgentService_AlgoServer{ctx: context.Background()}
-	mockStream.On("Recv").Return(&agent.AlgoRequest{Algorithm: []byte("algo"), Requirements: []byte("req")}, nil).Once()
-	mockStream.On("Recv").Return(&agent.AlgoRequest{}, io.EOF)
-	mockStream.On("SendAndClose", &agent.AlgoResponse{}).Return(nil)
-
-	mockService.On("Algo", context.Background(), agent.Algorithm{Algorithm: []byte("algo"), Requirements: []byte("req")}).Return(nil)
-
-	err := server.Algo(mockStream)
-	assert.NoError(t, err)
-
-	mockStream.AssertExpectations(t)
-	mockService.AssertExpectations(t)
-}
-
-func TestData(t *testing.T) {
-	mockService := new(mocks.Service)
-	server := NewServer(mockService)
-
-	mockStream := &MockAgentService_DataServer{ctx: context.Background()}
-	mockStream.On("Recv").Return(&agent.DataRequest{Dataset: []byte("data"), Filename: "test.txt"}, nil).Once()
-	mockStream.On("Recv").Return(&agent.DataRequest{}, io.EOF)
-	mockStream.On("SendAndClose", &agent.DataResponse{}).Return(nil)
-
-	mockService.On("Data", context.Background(), agent.Dataset{Dataset: []byte("data"), Filename: "test.txt"}).Return(nil)
-
-	err := server.Data(mockStream)
-	assert.NoError(t, err)
-
-	mockStream.AssertExpectations(t)
-	mockService.AssertExpectations(t)
-}
-
-func TestResult(t *testing.T) {
-	mockService := new(mocks.Service)
-	server := NewServer(mockService)
-
-	mockStream := &MockAgentService_ResultServer{ctx: context.Background()}
-	mockService.On("Result", mock.Anything).Return([]byte("result data"), nil)
-	mockStream.On("Send", mock.AnythingOfType("*agent.ResultResponse")).Return(nil)
-
-	err := server.Result(&agent.ResultRequest{}, mockStream)
-	assert.NoError(t, err)
-
-	mockStream.AssertExpectations(t)
-	mockService.AssertExpectations(t)
-}
-
-func TestAttestation(t *testing.T) {
-	mockService := new(mocks.Service)
-	server := NewServer(mockService)
-
-	mockStream := &MockAgentService_AttestationServer{ctx: context.Background()}
-	mockStream.On("Send", mock.AnythingOfType("*agent.AttestationResponse")).Return(nil)
-
-	reportData := [agent.ReportDataSize]byte{}
-	mockService.On("Attestation", mock.Anything, reportData).Return([]byte("attestation data"), nil)
-
-	err := server.Attestation(&agent.AttestationRequest{ReportData: reportData[:]}, mockStream)
-	assert.NoError(t, err)
-
-	mockService.AssertExpectations(t)
-}
-
-func TestDecodeAlgoRequest(t *testing.T) {
-	req := &agent.AlgoRequest{Algorithm: []byte("algo"), Requirements: []byte("req")}
-	decoded, err := decodeAlgoRequest(context.Background(), req)
-	assert.NoError(t, err)
-	assert.Equal(t, algoReq{Algorithm: []byte("algo"), Requirements: []byte("req")}, decoded)
-}
-
-func TestEncodeAlgoResponse(t *testing.T) {
-	encoded, err := encodeAlgoResponse(context.Background(), algoRes{})
-	assert.NoError(t, err)
-	assert.Equal(t, &agent.AlgoResponse{}, encoded)
-}
-
-func TestDecodeDataRequest(t *testing.T) {
-	req := &agent.DataRequest{Dataset: []byte("data"), Filename: "test.txt"}
-	decoded, err := decodeDataRequest(context.Background(), req)
-	assert.NoError(t, err)
-	assert.Equal(t, dataReq{Dataset: []byte("data"), Filename: "test.txt"}, decoded)
-}
-
-func TestEncodeDataResponse(t *testing.T) {
-	encoded, err := encodeDataResponse(context.Background(), dataRes{})
-	assert.NoError(t, err)
-	assert.Equal(t, &agent.DataResponse{}, encoded)
-}
-
-func TestDecodeResultRequest(t *testing.T) {
-	decoded, err := decodeResultRequest(context.Background(), &agent.ResultRequest{})
-	assert.NoError(t, err)
-	assert.Equal(t, resultReq{}, decoded)
-}
-
-func TestEncodeResultResponse(t *testing.T) {
-	encoded, err := encodeResultResponse(context.Background(), resultRes{File: []byte("result")})
-	assert.NoError(t, err)
-	assert.Equal(t, &agent.ResultResponse{File: []byte("result")}, encoded)
-}
-
-func TestDecodeAttestationRequest(t *testing.T) {
-	reportData := [agent.ReportDataSize]byte{}
-	req := &agent.AttestationRequest{ReportData: reportData[:]}
-	decoded, err := decodeAttestationRequest(context.Background(), req)
-	assert.NoError(t, err)
-	assert.Equal(t, attestationReq{ReportData: reportData}, decoded)
-}
-
-func TestEncodeAttestationResponse(t *testing.T) {
-	encoded, err := encodeAttestationResponse(context.Background(), attestationRes{File: []byte("attestation")})
-	assert.NoError(t, err)
-	assert.Equal(t, &agent.AttestationResponse{File: []byte("attestation")}, encoded)
-}
@@ -53,7 +53,7 @@ func (lm *loggingMiddleware) Data(ctx context.Context, dataset agent.Dataset) (e
 	return lm.svc.Data(ctx, dataset)
 }

-func (lm *loggingMiddleware) Result(ctx context.Context) (response []byte, err error) {
+func (lm *loggingMiddleware) Result(ctx context.Context, consumer string) (response []byte, err error) {
 	defer func(begin time.Time) {
 		message := fmt.Sprintf("Method Result took %s to complete", time.Since(begin))
 		if err != nil {
@@ -63,7 +63,7 @@ func (lm *loggingMiddleware) Result(ctx context.Context) (response []byte, err e
 		lm.logger.Info(fmt.Sprintf("%s without errors", message))
 	}(time.Now())

-	return lm.svc.Result(ctx)
+	return lm.svc.Result(ctx, consumer)
 }

 func (lm *loggingMiddleware) Attestation(ctx context.Context, reportData [agent.ReportDataSize]byte) (response []byte, err error) {
@@ -50,13 +50,13 @@ func (ms *metricsMiddleware) Data(ctx context.Context, dataset agent.Dataset) er
 	return ms.svc.Data(ctx, dataset)
 }

-func (ms *metricsMiddleware) Result(ctx context.Context) ([]byte, error) {
+func (ms *metricsMiddleware) Result(ctx context.Context, consumer string) ([]byte, error) {
 	defer func(begin time.Time) {
 		ms.counter.With("method", "result").Add(1)
 		ms.latency.With("method", "result").Observe(time.Since(begin).Seconds())
 	}(time.Now())

-	return ms.svc.Result(ctx)
+	return ms.svc.Result(ctx, consumer)
 }

 func (ms *metricsMiddleware) Attestation(ctx context.Context, reportData [agent.ReportDataSize]byte) ([]byte, error) {
@@ -1,173 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package auth
-
-import (
-	"context"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/rsa"
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/base64"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/ultravioletrs/cocos/agent"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
-)
-
-type UserRole string
-
-const (
-	UserMetadataKey                = "user-id"
-	SignatureMetadataKey           = "signature"
-	ConsumerRole          UserRole = "consumer"
-	DataProviderRole      UserRole = "data-provider"
-	AlgorithmProviderRole UserRole = "algorithm-provider"
-)
-
-var (
-	ErrMissingMetadata             = errors.New("missing metadata")
-	ErrInvalidMetadata             = errors.New("invalid metadata")
-	ErrSignatureVerificationFailed = errors.New("signature verification failed")
-)
-
-type Authenticator interface {
-	AuthenticateUser(ctx context.Context, role UserRole) (context.Context, error)
-}
-
-type service struct {
-	resultConsumers   []interface{}
-	datasetProviders  []interface{}
-	algorithmProvider interface{}
-}
-
-func New(manifest agent.Computation) (Authenticator, error) {
-	s := &service{}
-	for _, rc := range manifest.ResultConsumers {
-		pubKey, err := x509.ParsePKIXPublicKey(rc.UserKey)
-		if err != nil {
-			return nil, err
-		}
-
-		pKey, err := decodePublicKey(pubKey)
-		if err != nil {
-			return nil, err
-		}
-
-		s.resultConsumers = append(s.resultConsumers, pKey)
-	}
-
-	for _, dp := range manifest.Datasets {
-		pubKey, err := x509.ParsePKIXPublicKey(dp.UserKey)
-		if err != nil {
-			return nil, err
-		}
-
-		pKey, err := decodePublicKey(pubKey)
-		if err != nil {
-			return nil, err
-		}
-
-		s.datasetProviders = append(s.datasetProviders, pKey)
-	}
-
-	pubKey, err := x509.ParsePKIXPublicKey(manifest.Algorithm.UserKey)
-	if err != nil {
-		return nil, err
-	}
-
-	pKey, err := decodePublicKey(pubKey)
-	if err != nil {
-		return nil, err
-	}
-
-	s.algorithmProvider = pKey
-	return s, nil
-}
-
-func extractSignature(md metadata.MD) (string, error) {
-	signature := md.Get(SignatureMetadataKey)
-	if len(signature) != 1 {
-		return "", status.Errorf(codes.Unauthenticated, "invalid metadata")
-	}
-
-	return signature[0], nil
-}
-
-func verifySignature(role UserRole, signature string, publicKey any) error {
-	hash := sha256.Sum256([]byte(role))
-	sigByte, err := base64.StdEncoding.DecodeString(signature)
-	if err != nil {
-		return err
-	}
-
-	var ok bool
-
-	switch publicKey := publicKey.(type) {
-	case *rsa.PublicKey:
-		if err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hash[:], sigByte); err != nil {
-			return err
-		}
-		return nil
-	case *ecdsa.PublicKey:
-		ok = ecdsa.VerifyASN1(publicKey, hash[:], sigByte)
-	case ed25519.PublicKey:
-		ok = ed25519.Verify(publicKey, []byte(role), sigByte)
-	}
-
-	if !ok {
-		return ErrSignatureVerificationFailed
-	}
-
-	return nil
-}
-
-func (s *service) AuthenticateUser(ctx context.Context, role UserRole) (context.Context, error) {
-	md, ok := metadata.FromIncomingContext(ctx)
-	if !ok {
-		return nil, ErrMissingMetadata
-	}
-	signature, err := extractSignature(md)
-	if err != nil {
-		return nil, errors.Wrap(err, ErrInvalidMetadata)
-	}
-
-	switch role {
-	case ConsumerRole:
-		for i, rc := range s.resultConsumers {
-			if err := verifySignature(role, signature, rc); err == nil {
-				return agent.IndexToContext(ctx, i), nil
-			}
-		}
-	case DataProviderRole:
-		for _, dp := range s.datasetProviders {
-			if err := verifySignature(role, signature, dp); err == nil {
-				return ctx, nil
-			}
-		}
-	case AlgorithmProviderRole:
-		if err := verifySignature(role, signature, s.algorithmProvider); err == nil {
-			return ctx, nil
-		}
-	}
-
-	return ctx, ErrSignatureVerificationFailed
-}
-
-func decodePublicKey(key any) (pubKey any, err error) {
-	switch key := key.(type) {
-	case *rsa.PublicKey:
-		return key, nil
-	case *ecdsa.PublicKey:
-		return key, nil
-	case ed25519.PublicKey:
-		return key, nil
-	default:
-		return nil, errors.New("unsupported public key type")
-	}
-}
@@ -1,158 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package auth
-
-import (
-	"context"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/base64"
-	"testing"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/agent"
-	"google.golang.org/grpc/metadata"
-)
-
-func TestAuthenticateUser(t *testing.T) {
-	resultConsumerKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	require.NoError(t, err)
-
-	dataProviderKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	require.NoError(t, err)
-
-	pubEd25519Key, algorithmProviderKey, err := ed25519.GenerateKey(rand.Reader)
-	require.NoError(t, err)
-
-	resultConsumerPubKey, err := x509.MarshalPKIXPublicKey(&resultConsumerKey.PublicKey)
-	require.NoError(t, err)
-
-	dataProviderPubKey, err := x509.MarshalPKIXPublicKey(&dataProviderKey.PublicKey)
-	require.NoError(t, err)
-
-	algorithmProviderPubKey, err := x509.MarshalPKIXPublicKey(pubEd25519Key)
-	require.NoError(t, err)
-
-	manifest := agent.Computation{
-		ResultConsumers: []agent.ResultConsumer{{UserKey: resultConsumerPubKey}},
-		Datasets:        []agent.Dataset{{UserKey: dataProviderPubKey}},
-		Algorithm:       agent.Algorithm{UserKey: algorithmProviderPubKey},
-	}
-
-	auth, err := New(manifest)
-	if err != nil {
-		t.Fatalf("failed to create authenticator: %v", err)
-	}
-
-	testCases := []struct {
-		name        string
-		role        UserRole
-		key         any
-		expectedErr error
-	}{
-		{
-			name:        "valid result consumer",
-			role:        ConsumerRole,
-			key:         resultConsumerKey,
-			expectedErr: nil,
-		},
-		{
-			name:        "valid data provider",
-			role:        DataProviderRole,
-			key:         dataProviderKey,
-			expectedErr: nil,
-		},
-		{
-			name:        "valid algorithm provider",
-			role:        AlgorithmProviderRole,
-			key:         algorithmProviderKey,
-			expectedErr: nil,
-		},
-		{
-			name:        "invalid role",
-			role:        "invalid-role",
-			key:         resultConsumerKey,
-			expectedErr: ErrSignatureVerificationFailed,
-		},
-		{
-			name:        "invalid key",
-			role:        ConsumerRole,
-			key:         dataProviderKey,
-			expectedErr: ErrSignatureVerificationFailed,
-		},
-		{
-			name:        "missing signature",
-			role:        ConsumerRole,
-			key:         resultConsumerKey,
-			expectedErr: ErrInvalidMetadata,
-		},
-		{
-			name:        "missing metadata",
-			role:        ConsumerRole,
-			key:         resultConsumerKey,
-			expectedErr: ErrMissingMetadata,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			signature, err := signRole(tc.role, tc.key)
-			if err != nil {
-				t.Fatalf("failed to sign role: %v", err)
-			}
-
-			ctx := context.Background()
-
-			switch tc.name {
-			case "missing signature":
-				ctx = metadata.NewIncomingContext(ctx, metadata.Pairs())
-			case "missing metadata":
-			default:
-				ctx = metadata.NewIncomingContext(ctx, metadata.Pairs(SignatureMetadataKey, signature))
-			}
-
-			ctx, err = auth.AuthenticateUser(ctx, tc.role)
-			assert.True(t, errors.Contains(err, tc.expectedErr), "expected error %v, got %v", tc.expectedErr, err)
-
-			if err == nil {
-				switch id, ok := agent.IndexFromContext(ctx); {
-				case tc.role == ConsumerRole:
-					assert.True(t, ok, "expected index in context")
-					assert.Equal(t, 0, id, "expected index 0 in context")
-				default:
-					assert.False(t, ok, "expected no index in context")
-				}
-			}
-		})
-	}
-}
-
-func signRole(role UserRole, key crypto.PrivateKey) (string, error) {
-	var signature []byte
-	var err error
-
-	switch k := key.(type) {
-	case ed25519.PrivateKey:
-		signature, err = k.Sign(rand.Reader, []byte(role), crypto.Hash(0))
-	case *rsa.PrivateKey, *ecdsa.PrivateKey:
-		hash := sha256.Sum256([]byte(role))
-		signer := key.(crypto.Signer)
-		signature, err = signer.Sign(rand.Reader, hash[:], crypto.SHA256)
-	default:
-		return "", errors.New("unsupported key type")
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	return base64.StdEncoding.EncodeToString(signature), nil
-}
@@ -1,100 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	auth "github.com/ultravioletrs/cocos/agent/auth"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Authenticator is an autogenerated mock type for the Authenticator type
-type Authenticator struct {
-	mock.Mock
-}
-
-type Authenticator_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Authenticator) EXPECT() *Authenticator_Expecter {
-	return &Authenticator_Expecter{mock: &_m.Mock}
-}
-
-// AuthenticateUser provides a mock function with given fields: ctx, role
-func (_m *Authenticator) AuthenticateUser(ctx context.Context, role auth.UserRole) (context.Context, error) {
-	ret := _m.Called(ctx, role)
-
-	if len(ret) == 0 {
-		panic("no return value specified for AuthenticateUser")
-	}
-
-	var r0 context.Context
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, auth.UserRole) (context.Context, error)); ok {
-		return rf(ctx, role)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, auth.UserRole) context.Context); ok {
-		r0 = rf(ctx, role)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, auth.UserRole) error); ok {
-		r1 = rf(ctx, role)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Authenticator_AuthenticateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateUser'
-type Authenticator_AuthenticateUser_Call struct {
-	*mock.Call
-}
-
-// AuthenticateUser is a helper method to define mock.On call
-//   - ctx context.Context
-//   - role auth.UserRole
-func (_e *Authenticator_Expecter) AuthenticateUser(ctx interface{}, role interface{}) *Authenticator_AuthenticateUser_Call {
-	return &Authenticator_AuthenticateUser_Call{Call: _e.mock.On("AuthenticateUser", ctx, role)}
-}
-
-func (_c *Authenticator_AuthenticateUser_Call) Run(run func(ctx context.Context, role auth.UserRole)) *Authenticator_AuthenticateUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(auth.UserRole))
-	})
-	return _c
-}
-
-func (_c *Authenticator_AuthenticateUser_Call) Return(_a0 context.Context, _a1 error) *Authenticator_AuthenticateUser_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Authenticator_AuthenticateUser_Call) RunAndReturn(run func(context.Context, auth.UserRole) (context.Context, error)) *Authenticator_AuthenticateUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewAuthenticator creates a new instance of Authenticator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewAuthenticator(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Authenticator {
-	mock := &Authenticator{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
@@ -3,38 +3,34 @@
 package agent

 import (
-	"context"
 	"encoding/json"
 	"fmt"
-
-	"google.golang.org/grpc/metadata"
+	"reflect"
 )

-var _ fmt.Stringer = (*Datasets)(nil)
+var (
+	_ fmt.Stringer = (*Datasets)(nil)
+	_ fmt.Stringer = (*Algorithms)(nil)
+)

 type AgentConfig struct {
-	LogLevel     string `json:"log_level,omitempty"`
-	Host         string `json:"host,omitempty"`
-	Port         string `json:"port,omitempty"`
-	CertFile     string `json:"cert_file,omitempty"`
-	KeyFile      string `json:"server_key,omitempty"`
-	ServerCAFile string `json:"server_ca_file,omitempty"`
-	ClientCAFile string `json:"client_ca_file,omitempty"`
-	AttestedTls  bool   `json:"attested_tls,omitempty"`
+	LogLevel     string `json:"log_level"`
+	Host         string `json:"host"`
+	Port         string `json:"port"`
+	CertFile     string `json:"cert_file"`
+	KeyFile      string `json:"server_key"`
+	ServerCAFile string `json:"server_ca_file"`
+	ClientCAFile string `json:"client_ca_file"`
 }

 type Computation struct {
-	ID              string           `json:"id,omitempty"`
-	Name            string           `json:"name,omitempty"`
-	Description     string           `json:"description,omitempty"`
-	Datasets        Datasets         `json:"datasets,omitempty"`
-	Algorithm       Algorithm        `json:"algorithm,omitempty"`
-	ResultConsumers []ResultConsumer `json:"result_consumers,omitempty"`
-	AgentConfig     AgentConfig      `json:"agent_config,omitempty"`
-}
-
-type ResultConsumer struct {
-	UserKey []byte `json:"user_key,omitempty"`
+	ID              string      `json:"id,omitempty"`
+	Name            string      `json:"name,omitempty"`
+	Description     string      `json:"description,omitempty"`
+	Datasets        Datasets    `json:"datasets,omitempty"`
+	Algorithms      Algorithms  `json:"algorithms,omitempty"`
+	ResultConsumers []string    `json:"result_consumers,omitempty"`
+	AgentConfig     AgentConfig `json:"agent_config,omitempty"`
 }

 func (d *Datasets) String() string {
@@ -45,44 +41,42 @@ func (d *Datasets) String() string {
 	return string(dat)
 }

+func (a *Algorithms) String() string {
+	dat, err := json.Marshal(a)
+	if err != nil {
+		return ""
+	}
+	return string(dat)
+}
+
 type Dataset struct {
 	Dataset  []byte   `json:"-"`
 	Hash     [32]byte `json:"hash,omitempty"`
-	UserKey  []byte   `json:"user_key,omitempty"`
-	Filename string   `json:"filename,omitempty"`
+	Provider string   `json:"provider,omitempty"`
+	ID       string   `json:"id,omitempty"`
 }

 type Datasets []Dataset

 type Algorithm struct {
-	Algorithm    []byte   `json:"-"`
-	Hash         [32]byte `json:"hash,omitempty"`
-	UserKey      []byte   `json:"user_key,omitempty"`
-	Requirements []byte   `json:"-"`
+	Algorithm []byte   `json:"-"`
+	Hash      [32]byte `json:"hash,omitempty"`
+	Provider  string   `json:"provider,omitempty"`
+	ID        string   `json:"id,omitempty"`
 }

-type ManifestIndexKey struct{}
+type Algorithms []Algorithm

-func IndexToContext(ctx context.Context, index int) context.Context {
-	return context.WithValue(ctx, ManifestIndexKey{}, index)
-}
-
-func IndexFromContext(ctx context.Context) (int, bool) {
-	index, ok := ctx.Value(ManifestIndexKey{}).(int)
-	return index, ok
-}
-
-const DecompressKey = "decompress"
-
-func DecompressFromContext(ctx context.Context) bool {
-	vals := metadata.ValueFromIncomingContext(ctx, DecompressKey)
-	if len(vals) == 0 {
-		return false
+func containsID(slice interface{}, id string) int {
+	rangeOnMe := reflect.ValueOf(slice)
+	for i := 0; i < rangeOnMe.Len(); i++ {
+		s := rangeOnMe.Index(i)
+		f := s.FieldByName("ID")
+		if f.IsValid() {
+			if f.Interface() == id {
+				return i
+			}
+		}
 	}
-
-	return vals[0] == "true"
-}
-
-func DecompressToContext(ctx context.Context, decompress bool) context.Context {
-	return metadata.AppendToOutgoingContext(ctx, DecompressKey, fmt.Sprintf("%t", decompress))
+	return -1
 }
@@ -1,133 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"reflect"
-	"testing"
-
-	"google.golang.org/grpc/metadata"
-)
-
-func TestDatasetsString(t *testing.T) {
-	datasets := Datasets{
-		{
-			Hash:     [32]byte{1, 2, 3},
-			UserKey:  []byte("user_key"),
-			Filename: "test.dat",
-		},
-	}
-
-	expected := `[{"hash":[1,2,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"user_key":"dXNlcl9rZXk=","filename":"test.dat"}]`
-	result := datasets.String()
-
-	if result != expected {
-		t.Errorf("Datasets.String() = %v, want %v", result, expected)
-	}
-}
-
-func TestIndexToContext(t *testing.T) {
-	ctx := context.Background()
-	index := 5
-
-	newCtx := IndexToContext(ctx, index)
-	result, ok := IndexFromContext(newCtx)
-
-	if !ok {
-		t.Errorf("IndexFromContext() ok = false, want true")
-	}
-
-	if result != index {
-		t.Errorf("IndexFromContext() = %v, want %v", result, index)
-	}
-}
-
-func TestDecompressFromContext(t *testing.T) {
-	tests := []struct {
-		name     string
-		ctx      context.Context
-		expected bool
-	}{
-		{
-			name:     "No decompress metadata",
-			ctx:      context.Background(),
-			expected: false,
-		},
-		{
-			name: "Decompress true",
-			ctx: metadata.NewIncomingContext(
-				context.Background(),
-				metadata.Pairs(DecompressKey, "true"),
-			),
-			expected: true,
-		},
-		{
-			name: "Decompress false",
-			ctx: metadata.NewIncomingContext(
-				context.Background(),
-				metadata.Pairs(DecompressKey, "false"),
-			),
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := DecompressFromContext(tt.ctx)
-			if result != tt.expected {
-				t.Errorf("DecompressFromContext() = %v, want %v", result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestDecompressToContext(t *testing.T) {
-	ctx := context.Background()
-	decompress := true
-
-	newCtx := DecompressToContext(ctx, decompress)
-	md, ok := metadata.FromOutgoingContext(newCtx)
-
-	if !ok {
-		t.Errorf("metadata.FromOutgoingContext() ok = false, want true")
-	}
-
-	vals := md.Get(DecompressKey)
-	if len(vals) != 1 {
-		t.Errorf("len(md.Get(DecompressKey)) = %v, want 1", len(vals))
-	}
-
-	if vals[0] != "true" {
-		t.Errorf("md.Get(DecompressKey)[0] = %v, want 'true'", vals[0])
-	}
-}
-
-func TestAgentConfigJSON(t *testing.T) {
-	config := AgentConfig{
-		LogLevel:     "info",
-		Host:         "localhost",
-		Port:         "8080",
-		CertFile:     "cert.pem",
-		KeyFile:      "key.pem",
-		ServerCAFile: "server_ca.pem",
-		ClientCAFile: "client_ca.pem",
-		AttestedTls:  true,
-	}
-
-	data, err := json.Marshal(config)
-	if err != nil {
-		t.Fatalf("Failed to marshal AgentConfig: %v", err)
-	}
-
-	var unmarshaledConfig AgentConfig
-	err = json.Unmarshal(data, &unmarshaledConfig)
-	if err != nil {
-		t.Fatalf("Failed to unmarshal AgentConfig: %v", err)
-	}
-
-	if !reflect.DeepEqual(config, unmarshaledConfig) {
-		t.Errorf("Unmarshaled config does not match original. Got %+v, want %+v", unmarshaledConfig, config)
-	}
-}
@@ -4,8 +4,10 @@ package events

 import (
 	"encoding/json"
-	"io"
+	"time"

+	"github.com/mdlayher/vsock"
+	"github.com/ultravioletrs/cocos/pkg/manager"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -13,14 +15,28 @@ import (
 type service struct {
 	service       string
 	computationID string
-	conn          io.Writer
+	conn          *vsock.Conn
+}
+
+type AgentEvent struct {
+	EventType     string          `json:"event_type"`
+	Timestamp     time.Time       `json:"timestamp"`
+	ComputationID string          `json:"computation_id,omitempty"`
+	Details       json.RawMessage `json:"details,omitempty"`
+	Originator    string          `json:"originator"`
+	Status        string          `json:"status,omitempty"`
 }

 type Service interface {
 	SendEvent(event, status string, details json.RawMessage) error
+	Close() error
 }

-func New(svc, computationID string, conn io.Writer) (Service, error) {
+func New(svc, computationID string, sockPort uint32) (Service, error) {
+	conn, err := vsock.Dial(vsock.Host, sockPort, nil)
+	if err != nil {
+		return nil, err
+	}
 	return &service{
 		service:       svc,
 		computationID: computationID,
@@ -29,7 +45,7 @@ func New(svc, computationID string, conn io.Writer) (Service, error) {
 }

 func (s *service) SendEvent(event, status string, details json.RawMessage) error {
-	body := EventsLogs{Message: &EventsLogs_AgentEvent{AgentEvent: &AgentEvent{
+	body := manager.ClientStreamMessage{Message: &manager.ClientStreamMessage_AgentEvent{AgentEvent: &manager.AgentEvent{
 		EventType:     event,
 		Timestamp:     timestamppb.Now(),
 		ComputationId: s.computationID,
@@ -41,6 +57,12 @@ func (s *service) SendEvent(event, status string, details json.RawMessage) error
 	if err != nil {
 		return err
 	}
-	_, err = s.conn.Write(protoBody)
-	return err
+	if _, err := s.conn.Write(protoBody); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *service) Close() error {
+	return s.conn.Close()
 }
@@ -1,405 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.34.2
-// 	protoc        v5.28.1
-// source: agent/events/events.proto
-
-package events
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-type AgentEvent struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	EventType     string                 `protobuf:"bytes,1,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
-	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
-	ComputationId string                 `protobuf:"bytes,3,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
-	Details       []byte                 `protobuf:"bytes,4,opt,name=details,proto3" json:"details,omitempty"`
-	Originator    string                 `protobuf:"bytes,5,opt,name=originator,proto3" json:"originator,omitempty"`
-	Status        string                 `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
-}
-
-func (x *AgentEvent) Reset() {
-	*x = AgentEvent{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_agent_events_events_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *AgentEvent) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*AgentEvent) ProtoMessage() {}
-
-func (x *AgentEvent) ProtoReflect() protoreflect.Message {
-	mi := &file_agent_events_events_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use AgentEvent.ProtoReflect.Descriptor instead.
-func (*AgentEvent) Descriptor() ([]byte, []int) {
-	return file_agent_events_events_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *AgentEvent) GetEventType() string {
-	if x != nil {
-		return x.EventType
-	}
-	return ""
-}
-
-func (x *AgentEvent) GetTimestamp() *timestamppb.Timestamp {
-	if x != nil {
-		return x.Timestamp
-	}
-	return nil
-}
-
-func (x *AgentEvent) GetComputationId() string {
-	if x != nil {
-		return x.ComputationId
-	}
-	return ""
-}
-
-func (x *AgentEvent) GetDetails() []byte {
-	if x != nil {
-		return x.Details
-	}
-	return nil
-}
-
-func (x *AgentEvent) GetOriginator() string {
-	if x != nil {
-		return x.Originator
-	}
-	return ""
-}
-
-func (x *AgentEvent) GetStatus() string {
-	if x != nil {
-		return x.Status
-	}
-	return ""
-}
-
-type AgentLog struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
-	ComputationId string                 `protobuf:"bytes,2,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
-	Level         string                 `protobuf:"bytes,3,opt,name=level,proto3" json:"level,omitempty"`
-	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
-}
-
-func (x *AgentLog) Reset() {
-	*x = AgentLog{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_agent_events_events_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *AgentLog) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*AgentLog) ProtoMessage() {}
-
-func (x *AgentLog) ProtoReflect() protoreflect.Message {
-	mi := &file_agent_events_events_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use AgentLog.ProtoReflect.Descriptor instead.
-func (*AgentLog) Descriptor() ([]byte, []int) {
-	return file_agent_events_events_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *AgentLog) GetMessage() string {
-	if x != nil {
-		return x.Message
-	}
-	return ""
-}
-
-func (x *AgentLog) GetComputationId() string {
-	if x != nil {
-		return x.ComputationId
-	}
-	return ""
-}
-
-func (x *AgentLog) GetLevel() string {
-	if x != nil {
-		return x.Level
-	}
-	return ""
-}
-
-func (x *AgentLog) GetTimestamp() *timestamppb.Timestamp {
-	if x != nil {
-		return x.Timestamp
-	}
-	return nil
-}
-
-type EventsLogs struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Types that are assignable to Message:
-	//
-	//	*EventsLogs_AgentLog
-	//	*EventsLogs_AgentEvent
-	Message isEventsLogs_Message `protobuf_oneof:"message"`
-}
-
-func (x *EventsLogs) Reset() {
-	*x = EventsLogs{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_agent_events_events_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *EventsLogs) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EventsLogs) ProtoMessage() {}
-
-func (x *EventsLogs) ProtoReflect() protoreflect.Message {
-	mi := &file_agent_events_events_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use EventsLogs.ProtoReflect.Descriptor instead.
-func (*EventsLogs) Descriptor() ([]byte, []int) {
-	return file_agent_events_events_proto_rawDescGZIP(), []int{2}
-}
-
-func (m *EventsLogs) GetMessage() isEventsLogs_Message {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (x *EventsLogs) GetAgentLog() *AgentLog {
-	if x, ok := x.GetMessage().(*EventsLogs_AgentLog); ok {
-		return x.AgentLog
-	}
-	return nil
-}
-
-func (x *EventsLogs) GetAgentEvent() *AgentEvent {
-	if x, ok := x.GetMessage().(*EventsLogs_AgentEvent); ok {
-		return x.AgentEvent
-	}
-	return nil
-}
-
-type isEventsLogs_Message interface {
-	isEventsLogs_Message()
-}
-
-type EventsLogs_AgentLog struct {
-	AgentLog *AgentLog `protobuf:"bytes,1,opt,name=agent_log,json=agentLog,proto3,oneof"`
-}
-
-type EventsLogs_AgentEvent struct {
-	AgentEvent *AgentEvent `protobuf:"bytes,2,opt,name=agent_event,json=agentEvent,proto3,oneof"`
-}
-
-func (*EventsLogs_AgentLog) isEventsLogs_Message() {}
-
-func (*EventsLogs_AgentEvent) isEventsLogs_Message() {}
-
-var File_agent_events_events_proto protoreflect.FileDescriptor
-
-var file_agent_events_events_proto_rawDesc = []byte{
-	0x0a, 0x19, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x65,
-	0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x65, 0x76, 0x65,
-	0x6e, 0x74, 0x73, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x22, 0xde, 0x01, 0x0a, 0x0a, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x45, 0x76,
-	0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70,
-	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x79,
-	0x70, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
-	0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x25, 0x0a, 0x0e,
-	0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x04,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1e, 0x0a,
-	0x0a, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0a, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a,
-	0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73,
-	0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x9b, 0x01, 0x0a, 0x08, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x4c,
-	0x6f, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x25, 0x0a, 0x0e,
-	0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d,
-	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54,
-	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
-	0x61, 0x6d, 0x70, 0x22, 0x7f, 0x0a, 0x0a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x4c, 0x6f, 0x67,
-	0x73, 0x12, 0x2f, 0x0a, 0x09, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x6f, 0x67, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x41, 0x67,
-	0x65, 0x6e, 0x74, 0x4c, 0x6f, 0x67, 0x48, 0x00, 0x52, 0x08, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x4c,
-	0x6f, 0x67, 0x12, 0x35, 0x0a, 0x0b, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x76, 0x65, 0x6e,
-	0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73,
-	0x2e, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0a, 0x61,
-	0x67, 0x65, 0x6e, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x42, 0x0a, 0x5a, 0x08, 0x2e, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_agent_events_events_proto_rawDescOnce sync.Once
-	file_agent_events_events_proto_rawDescData = file_agent_events_events_proto_rawDesc
-)
-
-func file_agent_events_events_proto_rawDescGZIP() []byte {
-	file_agent_events_events_proto_rawDescOnce.Do(func() {
-		file_agent_events_events_proto_rawDescData = protoimpl.X.CompressGZIP(file_agent_events_events_proto_rawDescData)
-	})
-	return file_agent_events_events_proto_rawDescData
-}
-
-var file_agent_events_events_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
-var file_agent_events_events_proto_goTypes = []any{
-	(*AgentEvent)(nil),            // 0: events.AgentEvent
-	(*AgentLog)(nil),              // 1: events.AgentLog
-	(*EventsLogs)(nil),            // 2: events.EventsLogs
-	(*timestamppb.Timestamp)(nil), // 3: google.protobuf.Timestamp
-}
-var file_agent_events_events_proto_depIdxs = []int32{
-	3, // 0: events.AgentEvent.timestamp:type_name -> google.protobuf.Timestamp
-	3, // 1: events.AgentLog.timestamp:type_name -> google.protobuf.Timestamp
-	1, // 2: events.EventsLogs.agent_log:type_name -> events.AgentLog
-	0, // 3: events.EventsLogs.agent_event:type_name -> events.AgentEvent
-	4, // [4:4] is the sub-list for method output_type
-	4, // [4:4] is the sub-list for method input_type
-	4, // [4:4] is the sub-list for extension type_name
-	4, // [4:4] is the sub-list for extension extendee
-	0, // [0:4] is the sub-list for field type_name
-}
-
-func init() { file_agent_events_events_proto_init() }
-func file_agent_events_events_proto_init() {
-	if File_agent_events_events_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_agent_events_events_proto_msgTypes[0].Exporter = func(v any, i int) any {
-			switch v := v.(*AgentEvent); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_agent_events_events_proto_msgTypes[1].Exporter = func(v any, i int) any {
-			switch v := v.(*AgentLog); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_agent_events_events_proto_msgTypes[2].Exporter = func(v any, i int) any {
-			switch v := v.(*EventsLogs); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	file_agent_events_events_proto_msgTypes[2].OneofWrappers = []any{
-		(*EventsLogs_AgentLog)(nil),
-		(*EventsLogs_AgentEvent)(nil),
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_agent_events_events_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   3,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_agent_events_events_proto_goTypes,
-		DependencyIndexes: file_agent_events_events_proto_depIdxs,
-		MessageInfos:      file_agent_events_events_proto_msgTypes,
-	}.Build()
-	File_agent_events_events_proto = out.File
-	file_agent_events_events_proto_rawDesc = nil
-	file_agent_events_events_proto_goTypes = nil
-	file_agent_events_events_proto_depIdxs = nil
-}
@@ -1,33 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-syntax = "proto3";
-
-package events;
-
-import "google/protobuf/timestamp.proto";
-
-option go_package = "./events";
-
-message AgentEvent {
-  string event_type = 1;
-	google.protobuf.Timestamp timestamp = 2;
-	string	computation_id = 3;
-	bytes	details = 4;
-	string	originator = 5;
-	string	status = 6;
-}
-
-message AgentLog {
-  string message = 1;
-  string computation_id = 2;
-  string level = 3;
-  google.protobuf.Timestamp timestamp = 4;
-}
-
-message EventsLogs {
-  oneof message {
-    AgentLog agent_log = 1;
-    AgentEvent agent_event = 2;
-  }
-}
@@ -1,64 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package events
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"google.golang.org/protobuf/proto"
-)
-
-type mockConn struct {
-	writeErr error
-	buf      bytes.Buffer
-}
-
-func (m *mockConn) Write(p []byte) (n int, err error) {
-	if m.writeErr != nil {
-		return 0, m.writeErr
-	}
-	return m.buf.Write(p)
-}
-
-func TestSendEventSuccess(t *testing.T) {
-	mockConnection := &mockConn{}
-
-	svc, err := New("test_service", "12345", mockConnection)
-	assert.NoError(t, err)
-
-	details := json.RawMessage(`{"key": "value"}`)
-
-	err = svc.SendEvent("test_event", "success", details)
-	assert.NoError(t, err)
-
-	var writtenMessage EventsLogs
-	err = proto.Unmarshal(mockConnection.buf.Bytes(), &writtenMessage)
-	assert.NoError(t, err)
-
-	assert.Equal(t, "test_event", writtenMessage.GetAgentEvent().EventType)
-	assert.Equal(t, "12345", writtenMessage.GetAgentEvent().ComputationId)
-	assert.Equal(t, "test_service", writtenMessage.GetAgentEvent().Originator)
-	assert.Equal(t, "success", writtenMessage.GetAgentEvent().Status)
-
-	now := time.Now()
-	eventTimestamp := writtenMessage.GetAgentEvent().GetTimestamp().AsTime()
-	assert.WithinDuration(t, now, eventTimestamp, 1*time.Second)
-}
-
-func TestSendEventFailure(t *testing.T) {
-	mockConnection := &mockConn{writeErr: errors.New("write error")}
-
-	svc, err := New("test_service", "12345", mockConnection)
-	assert.NoError(t, err)
-
-	details := json.RawMessage(`{"key": "value"}`)
-
-	err = svc.SendEvent("test_event", "failure", details)
-	assert.Error(t, err)
-	assert.Equal(t, "write error", err.Error())
-}
@@ -1,87 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-package mocks
-
-import (
-	json "encoding/json"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-type Service_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Service) EXPECT() *Service_Expecter {
-	return &Service_Expecter{mock: &_m.Mock}
-}
-
-// SendEvent provides a mock function with given fields: event, status, details
-func (_m *Service) SendEvent(event string, status string, details json.RawMessage) error {
-	ret := _m.Called(event, status, details)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendEvent")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string, string, json.RawMessage) error); ok {
-		r0 = rf(event, status, details)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Service_SendEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendEvent'
-type Service_SendEvent_Call struct {
-	*mock.Call
-}
-
-// SendEvent is a helper method to define mock.On call
-//   - event string
-//   - status string
-//   - details json.RawMessage
-func (_e *Service_Expecter) SendEvent(event interface{}, status interface{}, details interface{}) *Service_SendEvent_Call {
-	return &Service_SendEvent_Call{Call: _e.mock.On("SendEvent", event, status, details)}
-}
-
-func (_c *Service_SendEvent_Call) Run(run func(event string, status string, details json.RawMessage)) *Service_SendEvent_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(string), args[1].(string), args[2].(json.RawMessage))
-	})
-	return _c
-}
-
-func (_c *Service_SendEvent_Call) Return(_a0 error) *Service_SendEvent_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Service_SendEvent_Call) RunAndReturn(run func(string, string, json.RawMessage) error) *Service_SendEvent_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
@@ -1,252 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	agent "github.com/ultravioletrs/cocos/agent"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// Service is an autogenerated mock type for the Service type
-type Service struct {
-	mock.Mock
-}
-
-type Service_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *Service) EXPECT() *Service_Expecter {
-	return &Service_Expecter{mock: &_m.Mock}
-}
-
-// Algo provides a mock function with given fields: ctx, algorithm
-func (_m *Service) Algo(ctx context.Context, algorithm agent.Algorithm) error {
-	ret := _m.Called(ctx, algorithm)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Algo")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, agent.Algorithm) error); ok {
-		r0 = rf(ctx, algorithm)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Service_Algo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Algo'
-type Service_Algo_Call struct {
-	*mock.Call
-}
-
-// Algo is a helper method to define mock.On call
-//   - ctx context.Context
-//   - algorithm agent.Algorithm
-func (_e *Service_Expecter) Algo(ctx interface{}, algorithm interface{}) *Service_Algo_Call {
-	return &Service_Algo_Call{Call: _e.mock.On("Algo", ctx, algorithm)}
-}
-
-func (_c *Service_Algo_Call) Run(run func(ctx context.Context, algorithm agent.Algorithm)) *Service_Algo_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(agent.Algorithm))
-	})
-	return _c
-}
-
-func (_c *Service_Algo_Call) Return(_a0 error) *Service_Algo_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Service_Algo_Call) RunAndReturn(run func(context.Context, agent.Algorithm) error) *Service_Algo_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Attestation provides a mock function with given fields: ctx, reportData
-func (_m *Service) Attestation(ctx context.Context, reportData [64]byte) ([]byte, error) {
-	ret := _m.Called(ctx, reportData)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Attestation")
-	}
-
-	var r0 []byte
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, [64]byte) ([]byte, error)); ok {
-		return rf(ctx, reportData)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context, [64]byte) []byte); ok {
-		r0 = rf(ctx, reportData)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]byte)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context, [64]byte) error); ok {
-		r1 = rf(ctx, reportData)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Service_Attestation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Attestation'
-type Service_Attestation_Call struct {
-	*mock.Call
-}
-
-// Attestation is a helper method to define mock.On call
-//   - ctx context.Context
-//   - reportData [64]byte
-func (_e *Service_Expecter) Attestation(ctx interface{}, reportData interface{}) *Service_Attestation_Call {
-	return &Service_Attestation_Call{Call: _e.mock.On("Attestation", ctx, reportData)}
-}
-
-func (_c *Service_Attestation_Call) Run(run func(ctx context.Context, reportData [64]byte)) *Service_Attestation_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].([64]byte))
-	})
-	return _c
-}
-
-func (_c *Service_Attestation_Call) Return(_a0 []byte, _a1 error) *Service_Attestation_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Service_Attestation_Call) RunAndReturn(run func(context.Context, [64]byte) ([]byte, error)) *Service_Attestation_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Data provides a mock function with given fields: ctx, dataset
-func (_m *Service) Data(ctx context.Context, dataset agent.Dataset) error {
-	ret := _m.Called(ctx, dataset)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Data")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, agent.Dataset) error); ok {
-		r0 = rf(ctx, dataset)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Service_Data_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Data'
-type Service_Data_Call struct {
-	*mock.Call
-}
-
-// Data is a helper method to define mock.On call
-//   - ctx context.Context
-//   - dataset agent.Dataset
-func (_e *Service_Expecter) Data(ctx interface{}, dataset interface{}) *Service_Data_Call {
-	return &Service_Data_Call{Call: _e.mock.On("Data", ctx, dataset)}
-}
-
-func (_c *Service_Data_Call) Run(run func(ctx context.Context, dataset agent.Dataset)) *Service_Data_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(agent.Dataset))
-	})
-	return _c
-}
-
-func (_c *Service_Data_Call) Return(_a0 error) *Service_Data_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *Service_Data_Call) RunAndReturn(run func(context.Context, agent.Dataset) error) *Service_Data_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Result provides a mock function with given fields: ctx
-func (_m *Service) Result(ctx context.Context) ([]byte, error) {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Result")
-	}
-
-	var r0 []byte
-	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context) ([]byte, error)); ok {
-		return rf(ctx)
-	}
-	if rf, ok := ret.Get(0).(func(context.Context) []byte); ok {
-		r0 = rf(ctx)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]byte)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
-		r1 = rf(ctx)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Service_Result_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Result'
-type Service_Result_Call struct {
-	*mock.Call
-}
-
-// Result is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *Service_Expecter) Result(ctx interface{}) *Service_Result_Call {
-	return &Service_Result_Call{Call: _e.mock.On("Result", ctx)}
-}
-
-func (_c *Service_Result_Call) Run(run func(ctx context.Context)) *Service_Result_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *Service_Result_Call) Return(_a0 []byte, _a1 error) *Service_Result_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
-func (_c *Service_Result_Call) RunAndReturn(run func(context.Context) ([]byte, error)) *Service_Result_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewService creates a new instance of Service. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewService(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *Service {
-	mock := &Service{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
@@ -1,207 +0,0 @@
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	context "context"
-
-	agent "github.com/ultravioletrs/cocos/agent"
-
-	metadata "google.golang.org/grpc/metadata"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// AgentService_AlgoClient is an autogenerated mock type for the AgentService_AlgoClient type
-type AgentService_AlgoClient struct {
-	mock.Mock
-}
-
-// CloseAndRecv provides a mock function with given fields:
-func (_m *AgentService_AlgoClient) CloseAndRecv() (*agent.AlgoResponse, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseAndRecv")
-	}
-
-	var r0 *agent.AlgoResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*agent.AlgoResponse, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *agent.AlgoResponse); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*agent.AlgoResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CloseSend provides a mock function with given fields:
-func (_m *AgentService_AlgoClient) CloseSend() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseSend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Context provides a mock function with given fields:
-func (_m *AgentService_AlgoClient) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// Header provides a mock function with given fields:
-func (_m *AgentService_AlgoClient) Header() (metadata.MD, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Header")
-	}
-
-	var r0 metadata.MD
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *AgentService_AlgoClient) RecvMsg(m interface{}) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Send provides a mock function with given fields: _a0
-func (_m *AgentService_AlgoClient) Send(_a0 *agent.AlgoRequest) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Send")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*agent.AlgoRequest) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *AgentService_AlgoClient) SendMsg(m interface{}) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Trailer provides a mock function with given fields:
-func (_m *AgentService_AlgoClient) Trailer() metadata.MD {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Trailer")
-	}
-
-	var r0 metadata.MD
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	return r0
-}
-
-// NewAgentService_AlgoClient creates a new instance of AgentService_AlgoClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewAgentService_AlgoClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *AgentService_AlgoClient {
-	mock := &AgentService_AlgoClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
@@ -1,207 +0,0 @@
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	context "context"
-
-	agent "github.com/ultravioletrs/cocos/agent"
-
-	metadata "google.golang.org/grpc/metadata"
-
-	mock "github.com/stretchr/testify/mock"
-)
-
-// AgentService_DataClient is an autogenerated mock type for the AgentService_DataClient type
-type AgentService_DataClient struct {
-	mock.Mock
-}
-
-// CloseAndRecv provides a mock function with given fields:
-func (_m *AgentService_DataClient) CloseAndRecv() (*agent.DataResponse, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseAndRecv")
-	}
-
-	var r0 *agent.DataResponse
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (*agent.DataResponse, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() *agent.DataResponse); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*agent.DataResponse)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CloseSend provides a mock function with given fields:
-func (_m *AgentService_DataClient) CloseSend() error {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for CloseSend")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Context provides a mock function with given fields:
-func (_m *AgentService_DataClient) Context() context.Context {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Context")
-	}
-
-	var r0 context.Context
-	if rf, ok := ret.Get(0).(func() context.Context); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(context.Context)
-		}
-	}
-
-	return r0
-}
-
-// Header provides a mock function with given fields:
-func (_m *AgentService_DataClient) Header() (metadata.MD, error) {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Header")
-	}
-
-	var r0 metadata.MD
-	var r1 error
-	if rf, ok := ret.Get(0).(func() (metadata.MD, error)); ok {
-		return rf()
-	}
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RecvMsg provides a mock function with given fields: m
-func (_m *AgentService_DataClient) RecvMsg(m interface{}) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for RecvMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Send provides a mock function with given fields: _a0
-func (_m *AgentService_DataClient) Send(_a0 *agent.DataRequest) error {
-	ret := _m.Called(_a0)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Send")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*agent.DataRequest) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// SendMsg provides a mock function with given fields: m
-func (_m *AgentService_DataClient) SendMsg(m interface{}) error {
-	ret := _m.Called(m)
-
-	if len(ret) == 0 {
-		panic("no return value specified for SendMsg")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
-		r0 = rf(m)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Trailer provides a mock function with given fields:
-func (_m *AgentService_DataClient) Trailer() metadata.MD {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for Trailer")
-	}
-
-	var r0 metadata.MD
-	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(metadata.MD)
-		}
-	}
-
-	return r0
-}
-
-// NewAgentService_DataClient creates a new instance of AgentService_DataClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewAgentService_DataClient(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *AgentService_DataClient {
-	mock := &AgentService_DataClient{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
@@ -9,70 +9,19 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"os"
-	"path/filepath"
+	"os/exec"
 	"slices"
-	sync "sync"

 	"github.com/google/go-sev-guest/client"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/binary"
-	"github.com/ultravioletrs/cocos/agent/algorithm/docker"
-	"github.com/ultravioletrs/cocos/agent/algorithm/python"
-	"github.com/ultravioletrs/cocos/agent/algorithm/wasm"
 	"github.com/ultravioletrs/cocos/agent/events"
-	"github.com/ultravioletrs/cocos/agent/statemachine"
-	"github.com/ultravioletrs/cocos/internal"
+	"github.com/ultravioletrs/cocos/pkg/socket"
 	"golang.org/x/crypto/sha3"
 )

 var _ Service = (*agentService)(nil)

-//go:generate stringer -type=AgentState
-type AgentState int
-
-const (
-	Idle AgentState = iota
-	ReceivingManifest
-	ReceivingAlgorithm
-	ReceivingData
-	Running
-	ConsumingResults
-	Complete
-	Failed
-)
-
-//go:generate stringer -type=AgentEvent
-type AgentEvent int
-
-const (
-	Start AgentEvent = iota
-	ManifestReceived
-	AlgorithmReceived
-	DataReceived
-	RunComplete
-	ResultsConsumed
-	RunFailed
-)
-
-//go:generate stringer -type=Status
-type Status uint8
-
-const (
-	IdleState Status = iota
-	InProgress
-	Ready
-	Completed
-	Terminated
-	Warning
-	Starting
-)
-
-const (
-	// ReportDataSize is the size of the report data expected by the attestation service.
-	ReportDataSize     = 64
-	algoFilePermission = 0o700
-)
+// ReportDataSize is the size of the report data expected by the attestation service.
+const ReportDataSize = 64

 var (
 	// ErrMalformedEntity indicates malformed entity specification (e.g.
@@ -81,24 +30,22 @@ var (
 	// ErrUnauthorizedAccess indicates missing or invalid credentials provided
 	// when accessing a protected resource.
 	ErrUnauthorizedAccess = errors.New("missing or invalid credentials provided")
-	// ErrUndeclaredAlgorithm indicates algorithm was not declared in computation manifest.
-	ErrUndeclaredDataset = errors.New("dataset not declared in computation manifest")
-	// ErrAllManifestItemsReceived indicates no new computation manifest items expected.
-	ErrAllManifestItemsReceived = errors.New("all expected manifest Items have been received")
-	// ErrUndeclaredConsumer indicates the consumer requesting results in not declared in computation manifest.
-	ErrUndeclaredConsumer = errors.New("result consumer is undeclared in computation manifest")
-	// ErrResultsNotReady indicates the computation results are not ready.
-	ErrResultsNotReady = errors.New("computation results are not yet ready")
-	// ErrStateNotReady agent received a request in the wrong state.
-	ErrStateNotReady = errors.New("agent not expecting this operation in the current state")
-	// ErrHashMismatch provided algorithm/dataset does not match hash in manifest.
-	ErrHashMismatch = errors.New("malformed data, hash does not match manifest")
-	// ErrFileNameMismatch provided dataset filename does not match filename in manifest.
-	ErrFileNameMismatch = errors.New("malformed data, filename does not match manifest")
-	// ErrAllResultsConsumed indicates all results have been consumed.
-	ErrAllResultsConsumed = errors.New("all results have been consumed by declared consumers")
-	// ErrAttestationFailed attestation failed.
-	ErrAttestationFailed = errors.New("failed to get raw quote")
+	// errUndeclaredAlgorithm indicates algorithm was not declared in computation manifest.
+	errUndeclaredAlgorithm = errors.New("algorithm not declared in computation manifest")
+	// errUndeclaredAlgorithm indicates algorithm was not declared in computation manifest.
+	errUndeclaredDataset = errors.New("dataset not declared in computation manifest")
+	// errProviderMissmatch algorithm/dataset provider does not match computation manifest.
+	errProviderMissmatch = errors.New("provider does not match declaration on manifest")
+	// errAllManifestItemsReceived indicates no new computation manifest items expected.
+	errAllManifestItemsReceived = errors.New("all expected manifest Items have been received")
+	// errUndeclaredConsumer indicates the consumer requesting results in not declared in computation manifest.
+	errUndeclaredConsumer = errors.New("result consumer is undeclared in computation manifest")
+	// errResultsNotReady indicates the computation results are not ready.
+	errResultsNotReady = errors.New("computation results are not yet ready")
+	// errStateNotReady agent received a request in the wrong state.
+	errStateNotReady = errors.New("agent not expecting this operation in the current state")
+	// errHashMismatch provided algorithm/dataset does not match hash in manifest.
+	errHashMismatch = errors.New("malformed data, hash does not match manifest")
 )

 // Service specifies an API that must be fullfiled by the domain service
@@ -106,243 +53,142 @@ var (
 type Service interface {
 	Algo(ctx context.Context, algorithm Algorithm) error
 	Data(ctx context.Context, dataset Dataset) error
-	Result(ctx context.Context) ([]byte, error)
+	Result(ctx context.Context, consumer string) ([]byte, error)
 	Attestation(ctx context.Context, reportData [ReportDataSize]byte) ([]byte, error)
 }

 type agentService struct {
-	mu              sync.Mutex
-	computation     Computation               // Holds the current computation request details.
-	algorithm       algorithm.Algorithm       // Filepath to the algorithm received for the computation.
-	result          []byte                    // Stores the result of the computation.
-	sm              statemachine.StateMachine // Manages the state transitions of the agent service.
-	runError        error                     // Stores any error encountered during the computation run.
-	eventSvc        events.Service            // Service for publishing events related to computation.
-	quoteProvider   client.QuoteProvider      // Provider for generating attestation quotes.
-	logger          *slog.Logger              // Logger for the agent service.
-	resultsConsumed bool                      // Indicates if the results have been consumed.
+	computation Computation    // Holds the current computation request details.
+	algorithms  [][]byte       // Stores the algorithms received for the computation.
+	datasets    [][]byte       // Stores the datasets received for the computation.
+	result      []byte         // Stores the result of the computation.
+	sm          *StateMachine  // Manages the state transitions of the agent service.
+	runError    error          // Stores any error encountered during the computation run.
+	eventSvc    events.Service // Service for publishing events related to computation.
 }

+const (
+	socketPath = "unix_socket"
+	pyRuntime  = "python3"
+)
+
 var _ Service = (*agentService)(nil)

 // New instantiates the agent service implementation.
-func New(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp Computation, quoteProvider client.QuoteProvider) Service {
-	sm := statemachine.NewStateMachine(Idle)
+func New(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp Computation) Service {
 	svc := &agentService{
-		sm:            sm,
-		eventSvc:      eventSvc,
-		quoteProvider: quoteProvider,
-		logger:        logger,
-		computation:   cmp,
+		sm:       NewStateMachine(logger),
+		eventSvc: eventSvc,
 	}
+	go svc.sm.Start(ctx)
+	svc.sm.SendEvent(start)
+	svc.sm.StateFunctions[idle] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[receivingManifests] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[receivingAlgorithms] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[receivingData] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[resultsReady] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[complete] = svc.publishEvent("in-progress", json.RawMessage{})
+	svc.sm.StateFunctions[running] = svc.runComputation

-	transitions := []statemachine.Transition{
-		{From: Idle, Event: Start, To: ReceivingManifest},
-		{From: ReceivingManifest, Event: ManifestReceived, To: ReceivingAlgorithm},
-	}
-
-	if len(cmp.Datasets) == 0 {
-		transitions = append(transitions, statemachine.Transition{From: ReceivingAlgorithm, Event: AlgorithmReceived, To: Running})
-	} else {
-		transitions = append(transitions, statemachine.Transition{From: ReceivingAlgorithm, Event: AlgorithmReceived, To: ReceivingData})
-		transitions = append(transitions, statemachine.Transition{From: ReceivingData, Event: DataReceived, To: Running})
-	}
-
-	transitions = append(transitions, []statemachine.Transition{
-		{From: Running, Event: RunComplete, To: ConsumingResults},
-		{From: Running, Event: RunFailed, To: Failed},
-		{From: ConsumingResults, Event: ResultsConsumed, To: Complete},
-	}...)
-
-	for _, t := range transitions {
-		sm.AddTransition(t)
-	}
-
-	sm.SetAction(Idle, svc.publishEvent(IdleState.String()))
-	sm.SetAction(ReceivingManifest, svc.publishEvent(InProgress.String()))
-	sm.SetAction(ReceivingAlgorithm, svc.publishEvent(InProgress.String()))
-	sm.SetAction(ReceivingData, svc.publishEvent(InProgress.String()))
-	sm.SetAction(Running, svc.runComputation)
-	sm.SetAction(ConsumingResults, svc.publishEvent(Ready.String()))
-	sm.SetAction(Complete, svc.publishEvent(Completed.String()))
-	sm.SetAction(Failed, svc.publishEvent(Failed.String()))
-
-	go func() {
-		if err := sm.Start(ctx); err != nil {
-			logger.Error(err.Error())
-		}
-	}()
-	sm.SendEvent(Start)
-	defer sm.SendEvent(ManifestReceived)
-
+	svc.computation = cmp
+	svc.sm.SendEvent(manifestsReceived)
 	return svc
 }

-func (as *agentService) Algo(ctx context.Context, algo Algorithm) error {
-	if as.sm.GetState() != ReceivingAlgorithm {
-		return ErrStateNotReady
+func (as *agentService) Algo(ctx context.Context, algorithm Algorithm) error {
+	if as.sm.GetState() != receivingAlgorithms {
+		return errStateNotReady
 	}
-	as.mu.Lock()
-	defer as.mu.Unlock()
-	if as.algorithm != nil {
-		return ErrAllManifestItemsReceived
+	if len(as.computation.Algorithms) == 0 {
+		return errAllManifestItemsReceived
 	}

-	hash := sha3.Sum256(algo.Algorithm)
+	hash := sha3.Sum256(algorithm.Algorithm)

-	if hash != as.computation.Algorithm.Hash {
-		return ErrHashMismatch
-	}
-
-	currentDir, err := os.Getwd()
-	if err != nil {
-		return fmt.Errorf("error getting current directory: %v", err)
-	}
-
-	f, err := os.Create(filepath.Join(currentDir, "algo"))
-	if err != nil {
-		return fmt.Errorf("error creating algorithm file: %v", err)
-	}
-
-	if _, err := f.Write(algo.Algorithm); err != nil {
-		return fmt.Errorf("error writing algorithm to file: %v", err)
-	}
-
-	if err := os.Chmod(f.Name(), algoFilePermission); err != nil {
-		return fmt.Errorf("error changing file permissions: %v", err)
-	}
-
-	if err := f.Close(); err != nil {
-		return fmt.Errorf("error closing file: %v", err)
-	}
-
-	algoType := algorithm.AlgorithmTypeFromContext(ctx)
-	if algoType == "" {
-		algoType = string(algorithm.AlgoTypeBin)
-	}
-
-	args := algorithm.AlgorithmArgsFromContext(ctx)
-
-	switch algoType {
-	case string(algorithm.AlgoTypeBin):
-		as.algorithm = binary.NewAlgorithm(as.logger, as.eventSvc, f.Name(), args)
-	case string(algorithm.AlgoTypePython):
-		var requirementsFile string
-		if len(algo.Requirements) > 0 {
-			fr, err := os.CreateTemp("", "requirements.txt")
-			if err != nil {
-				return fmt.Errorf("error creating requirments file: %v", err)
-			}
-
-			if _, err := fr.Write(algo.Requirements); err != nil {
-				return fmt.Errorf("error writing requirements to file: %v", err)
-			}
-			if err := fr.Close(); err != nil {
-				return fmt.Errorf("error closing file: %v", err)
-			}
-			requirementsFile = fr.Name()
+	index := containsID(as.computation.Algorithms, algorithm.ID)
+	switch index {
+	case -1:
+		return errUndeclaredAlgorithm
+	default:
+		if as.computation.Algorithms[index].Provider != algorithm.Provider {
+			return errProviderMissmatch
 		}
-		runtime := python.PythonRunTimeFromContext(ctx)
-		as.algorithm = python.NewAlgorithm(as.logger, as.eventSvc, runtime, requirementsFile, f.Name(), args)
-	case string(algorithm.AlgoTypeWasm):
-		as.algorithm = wasm.NewAlgorithm(as.logger, as.eventSvc, f.Name(), args)
-	case string(algorithm.AlgoTypeDocker):
-		as.algorithm = docker.NewAlgorithm(as.logger, as.eventSvc, f.Name())
+		if hash != as.computation.Algorithms[index].Hash {
+			return errHashMismatch
+		}
+		as.computation.Algorithms = slices.Delete(as.computation.Algorithms, index, index+1)
 	}

-	if err := os.Mkdir(algorithm.DatasetsDir, 0o755); err != nil {
-		return fmt.Errorf("error creating datasets directory: %v", err)
-	}
+	as.algorithms = append(as.algorithms, algorithm.Algorithm)

-	if as.algorithm != nil {
-		as.sm.SendEvent(AlgorithmReceived)
+	if len(as.computation.Algorithms) == 0 {
+		as.sm.SendEvent(algorithmsReceived)
 	}

 	return nil
 }

 func (as *agentService) Data(ctx context.Context, dataset Dataset) error {
-	if as.sm.GetState() != ReceivingData {
-		return ErrStateNotReady
+	if as.sm.GetState() != receivingData {
+		return errStateNotReady
 	}
-	as.mu.Lock()
-	defer as.mu.Unlock()
 	if len(as.computation.Datasets) == 0 {
-		return ErrAllManifestItemsReceived
+		return errAllManifestItemsReceived
 	}

 	hash := sha3.Sum256(dataset.Dataset)

-	matched := false
-	for i, d := range as.computation.Datasets {
-		if hash == d.Hash {
-			if d.Filename != "" && d.Filename != dataset.Filename {
-				return ErrFileNameMismatch
-			}
-
-			as.computation.Datasets = slices.Delete(as.computation.Datasets, i, i+1)
-
-			if DecompressFromContext(ctx) {
-				if err := internal.UnzipFromMemory(dataset.Dataset, algorithm.DatasetsDir); err != nil {
-					return fmt.Errorf("error decompressing dataset: %v", err)
-				}
-			} else {
-				f, err := os.Create(fmt.Sprintf("%s/%s", algorithm.DatasetsDir, dataset.Filename))
-				if err != nil {
-					return fmt.Errorf("error creating dataset file: %v", err)
-				}
-
-				if _, err := f.Write(dataset.Dataset); err != nil {
-					return fmt.Errorf("error writing dataset to file: %v", err)
-				}
-				if err := f.Close(); err != nil {
-					return fmt.Errorf("error closing file: %v", err)
-				}
-			}
-
-			matched = true
-			break
+	index := containsID(as.computation.Datasets, dataset.ID)
+	switch index {
+	case -1:
+		return errUndeclaredDataset
+	default:
+		if as.computation.Datasets[index].Provider != dataset.Provider {
+			return errProviderMissmatch
 		}
+		if hash != as.computation.Datasets[index].Hash {
+			return errHashMismatch
+		}
+		as.computation.Datasets = slices.Delete(as.computation.Datasets, index, index+1)
 	}

-	if !matched {
-		return ErrUndeclaredDataset
-	}
+	as.datasets = append(as.datasets, dataset.Dataset)

 	if len(as.computation.Datasets) == 0 {
-		defer as.sm.SendEvent(DataReceived)
+		as.sm.SendEvent(dataReceived)
 	}

 	return nil
 }

-func (as *agentService) Result(ctx context.Context) ([]byte, error) {
-	currentState := as.sm.GetState()
-	if currentState != ConsumingResults && currentState != Complete && currentState != Failed {
-		return []byte{}, ErrResultsNotReady
+func (as *agentService) Result(ctx context.Context, consumer string) ([]byte, error) {
+	if as.sm.GetState() != resultsReady {
+		return []byte{}, errResultsNotReady
+	}
+	if len(as.computation.ResultConsumers) == 0 {
+		return []byte{}, errAllManifestItemsReceived
+	}
+	index := slices.Index(as.computation.ResultConsumers, consumer)
+	switch index {
+	case -1:
+		return []byte{}, errUndeclaredConsumer
+	default:
+		as.computation.ResultConsumers = slices.Delete(as.computation.ResultConsumers, index, index+1)
 	}

-	index, ok := IndexFromContext(ctx)
-	if !ok {
-		return []byte{}, ErrUndeclaredConsumer
+	if len(as.computation.ResultConsumers) == 0 {
+		as.sm.SendEvent(resultsConsumed)
 	}
-
-	as.mu.Lock()
-	defer as.mu.Unlock()
-	if index < 0 || index >= len(as.computation.ResultConsumers) {
-		return []byte{}, ErrUndeclaredConsumer
-	}
-
-	if !as.resultsConsumed && currentState == ConsumingResults {
-		as.resultsConsumed = true
-		defer as.sm.SendEvent(ResultsConsumed)
-	}
-
+	// Return the result file or an error
 	return as.result, as.runError
 }

 func (as *agentService) Attestation(ctx context.Context, reportData [ReportDataSize]byte) ([]byte, error) {
-	rawQuote, err := as.quoteProvider.GetRawQuote(reportData)
+	provider, err := client.GetQuoteProvider()
+	if err != nil {
+		return []byte{}, err
+	}
+	rawQuote, err := provider.GetRawQuote(reportData)
 	if err != nil {
 		return []byte{}, err
 	}
@@ -350,58 +196,61 @@ func (as *agentService) Attestation(ctx context.Context, reportData [ReportDataS
 	return rawQuote, nil
 }

-func (as *agentService) runComputation(state statemachine.State) {
-	as.publishEvent(Starting.String())(state)
-	as.logger.Debug("computation run started")
-	defer func() {
-		if as.runError != nil {
-			as.sm.SendEvent(RunFailed)
-		} else {
-			as.sm.SendEvent(RunComplete)
-		}
-	}()
-
-	if err := os.Mkdir(algorithm.ResultsDir, 0o755); err != nil {
-		as.runError = fmt.Errorf("error creating results directory: %s", err.Error())
-		as.logger.Warn(as.runError.Error())
-		as.publishEvent(Failed.String())(state)
-		return
-	}
-
-	defer func() {
-		if err := os.RemoveAll(algorithm.ResultsDir); err != nil {
-			as.logger.Warn(fmt.Sprintf("error removing results directory and its contents: %s", err.Error()))
-		}
-		if err := os.RemoveAll(algorithm.DatasetsDir); err != nil {
-			as.logger.Warn(fmt.Sprintf("error removing datasets directory and its contents: %s", err.Error()))
-		}
-	}()
-
-	as.publishEvent(InProgress.String())(state)
-	if err := as.algorithm.Run(); err != nil {
-		as.runError = err
-		as.logger.Warn(fmt.Sprintf("failed to run computation: %s", err.Error()))
-		as.publishEvent(Failed.String())(state)
-		return
-	}
-
-	results, err := internal.ZipDirectoryToMemory(algorithm.ResultsDir)
+func (as *agentService) runComputation() {
+	as.publishEvent("starting", json.RawMessage{})()
+	as.sm.logger.Debug("computation run started")
+	defer as.sm.SendEvent(runComplete)
+	as.publishEvent("in-progress", json.RawMessage{})()
+	result, err := run(as.algorithms[0], as.datasets[0])
 	if err != nil {
 		as.runError = err
-		as.logger.Warn(fmt.Sprintf("failed to zip results: %s", err.Error()))
-		as.publishEvent(Failed.String())(state)
+		as.publishEvent("failed", json.RawMessage{})()
 		return
 	}
-
-	as.publishEvent(Completed.String())(state)
-
-	as.result = results
+	as.publishEvent("complete", json.RawMessage{})()
+	as.result = result
 }

-func (as *agentService) publishEvent(status string) statemachine.Action {
-	return func(state statemachine.State) {
-		if err := as.eventSvc.SendEvent(state.String(), status, json.RawMessage{}); err != nil {
-			as.logger.Warn(err.Error())
+func (as *agentService) publishEvent(status string, details json.RawMessage) func() {
+	return func() {
+		if err := as.eventSvc.SendEvent(as.sm.State.String(), status, details); err != nil {
+			as.sm.logger.Warn(err.Error())
 		}
 	}
 }
+
+func run(algoContent, dataContent []byte) ([]byte, error) {
+	listener, err := socket.StartUnixSocketServer(socketPath)
+	if err != nil {
+		return nil, fmt.Errorf("error creating stdout pipe: %v", err)
+	}
+	defer listener.Close()
+
+	// Create channels for received data and errors
+	dataChannel := make(chan []byte)
+	errorChannel := make(chan error)
+
+	var result []byte
+
+	go socket.AcceptConnection(listener, dataChannel, errorChannel)
+
+	// Construct the Python script content with CSV data as a command-line argument
+	script := string(algoContent)
+	data := string(dataContent)
+	cmd := exec.Command(pyRuntime, "-c", script, data, socketPath)
+
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("error starting Python script: %v", err)
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return nil, fmt.Errorf("python script execution error: %v", err)
+	}
+
+	select {
+	case result = <-dataChannel:
+		return result, nil
+	case err = <-errorChannel:
+		return nil, fmt.Errorf("error receiving data: %v", err)
+	}
+}
@@ -1,406 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package agent
-
-import (
-	"context"
-	"crypto/rand"
-	"log"
-	"os"
-	"testing"
-	"time"
-
-	mglog "github.com/absmach/magistrala/logger"
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/python"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-	"github.com/ultravioletrs/cocos/agent/statemachine"
-	smmocks "github.com/ultravioletrs/cocos/agent/statemachine/mocks"
-	"github.com/ultravioletrs/cocos/pkg/attestation/quoteprovider"
-	mocks2 "github.com/ultravioletrs/cocos/pkg/attestation/quoteprovider/mocks"
-	"golang.org/x/crypto/sha3"
-	"google.golang.org/grpc/metadata"
-)
-
-var (
-	algoPath = "../test/manual/algo/lin_reg.py"
-	reqPath  = "../test/manual/algo/requirements.txt"
-	dataPath = "../test/manual/data/iris.csv"
-)
-
-const datasetFile = "iris.csv"
-
-func TestAlgo(t *testing.T) {
-	events := new(mocks.Service)
-
-	evCall := events.On("SendEvent", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	defer evCall.Unset()
-
-	qp, err := quoteprovider.GetQuoteProvider()
-	require.NoError(t, err)
-
-	algo, err := os.ReadFile(algoPath)
-	require.NoError(t, err)
-
-	algoHash := sha3.Sum256(algo)
-
-	reqFile, err := os.ReadFile(reqPath)
-	require.NoError(t, err)
-
-	testCases := []struct {
-		name     string
-		err      error
-		algo     Algorithm
-		algoType string
-	}{
-		{
-			name: "Test Algo successfully",
-			algo: Algorithm{
-				Algorithm: algo,
-				Hash:      algoHash,
-			},
-			algoType: "python",
-			err:      nil,
-		},
-		{
-			name: "Test Algo successfully with requirements file",
-			algo: Algorithm{
-				Algorithm:    algo,
-				Hash:         algoHash,
-				Requirements: reqFile,
-			},
-			algoType: "python",
-			err:      nil,
-		},
-		{
-			name: "Test Algo type binary successfully",
-			algo: Algorithm{
-				Algorithm: algo,
-				Hash:      algoHash,
-			},
-			algoType: "bin",
-			err:      nil,
-		},
-		{
-			name: "Test Algo type wasm successfully",
-			algo: Algorithm{
-				Algorithm: algo,
-				Hash:      algoHash,
-			},
-			algoType: "wasm",
-			err:      nil,
-		},
-		{
-			name: "Test Algo type docker successfully",
-			algo: Algorithm{
-				Algorithm: algo,
-				Hash:      algoHash,
-			},
-			algoType: "docker",
-			err:      nil,
-		},
-		{
-			name:     "Test algo hash mismatch",
-			algo:     Algorithm{},
-			algoType: "python",
-			err:      ErrHashMismatch,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			err = os.RemoveAll("datasets")
-			require.NoError(t, err)
-
-			ctx := metadata.NewIncomingContext(context.Background(),
-				metadata.Pairs(algorithm.AlgoTypeKey, tc.algoType, python.PyRuntimeKey, python.PyRuntime),
-			)
-
-			ctx, cancel := context.WithCancel(ctx)
-			defer cancel()
-			svc := New(ctx, mglog.NewMock(), events, testComputation(t), qp)
-
-			time.Sleep(300 * time.Millisecond)
-
-			err = svc.Algo(ctx, tc.algo)
-			assert.True(t, errors.Contains(err, tc.err), "expected %v, got %v", tc.err, err)
-			t.Cleanup(func() {
-				err = os.RemoveAll("venv")
-				err = os.RemoveAll("algo")
-				err = os.RemoveAll("datasets")
-			})
-		})
-	}
-}
-
-func TestData(t *testing.T) {
-	events := new(mocks.Service)
-
-	evCall := events.On("SendEvent", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	defer evCall.Unset()
-
-	qp, err := quoteprovider.GetQuoteProvider()
-	require.NoError(t, err)
-
-	algo, err := os.ReadFile(algoPath)
-	require.NoError(t, err)
-
-	algoHash := sha3.Sum256(algo)
-
-	alg := Algorithm{
-		Hash:      algoHash,
-		Algorithm: algo,
-	}
-
-	data, err := os.ReadFile(dataPath)
-	require.NoError(t, err)
-
-	dataHash := sha3.Sum256(data)
-
-	cases := []struct {
-		name string
-		data Dataset
-		err  error
-	}{
-		{
-			name: "Test data successfully",
-			data: Dataset{
-				Hash:     dataHash,
-				Dataset:  data,
-				Filename: datasetFile,
-			},
-		},
-		{
-			name: "Test State not ready",
-			data: Dataset{
-				Dataset:  data,
-				Hash:     dataHash,
-				Filename: datasetFile,
-			},
-			err: ErrStateNotReady,
-		},
-		{
-			name: "Test File name does not match manifest",
-			data: Dataset{
-				Dataset:  data,
-				Hash:     dataHash,
-				Filename: "invalid",
-			},
-			err: ErrFileNameMismatch,
-		},
-		{
-			name: "Test dataset not declared in manifest",
-			data: Dataset{
-				Filename: datasetFile,
-			},
-			err: ErrUndeclaredDataset,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := metadata.NewIncomingContext(context.Background(),
-				metadata.Pairs(
-					algorithm.AlgoTypeKey, "python",
-					python.PyRuntimeKey, python.PyRuntime),
-			)
-
-			if tc.err != ErrUndeclaredDataset {
-				ctx = IndexToContext(ctx, 0)
-			}
-
-			ctx, cancel := context.WithCancel(ctx)
-			defer cancel()
-
-			comp := testComputation(t)
-
-			svc := New(ctx, mglog.NewMock(), events, comp, qp)
-			time.Sleep(300 * time.Millisecond)
-
-			if tc.err != ErrStateNotReady {
-				_ = svc.Algo(ctx, alg)
-				time.Sleep(300 * time.Millisecond)
-			}
-			err = svc.Data(ctx, tc.data)
-			assert.True(t, errors.Contains(err, tc.err), "expected %v, got %v", tc.err, err)
-			t.Cleanup(func() {
-				_ = os.RemoveAll("datasets")
-				_ = os.RemoveAll("results")
-				err = os.RemoveAll("venv")
-				err = os.RemoveAll("algo")
-			})
-		})
-	}
-}
-
-func TestResult(t *testing.T) {
-	events := new(mocks.Service)
-
-	evCall := events.On("SendEvent", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	defer evCall.Unset()
-
-	qp, err := quoteprovider.GetQuoteProvider()
-	require.NoError(t, err)
-
-	cases := []struct {
-		name     string
-		err      error
-		setup    func(svc *agentService)
-		ctxSetup func(ctx context.Context) context.Context
-		state    statemachine.State
-	}{
-		{
-			name: "Test results not ready",
-			err:  ErrResultsNotReady,
-			setup: func(svc *agentService) {
-			},
-			state: Running,
-		},
-		{
-			name: "Test undeclared consumer",
-			err:  ErrUndeclaredConsumer,
-			setup: func(svc *agentService) {
-				svc.computation.ResultConsumers = []ResultConsumer{{UserKey: []byte("user")}}
-			},
-			ctxSetup: func(ctx context.Context) context.Context {
-				return ctx
-			},
-			state: ConsumingResults,
-		},
-		{
-			name: "Test results consumed and event sent",
-			err:  nil,
-			setup: func(svc *agentService) {
-				svc.computation.ResultConsumers = []ResultConsumer{{UserKey: []byte("key")}}
-			},
-			ctxSetup: func(ctx context.Context) context.Context {
-				return IndexToContext(ctx, 0)
-			},
-			state: ConsumingResults,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := metadata.NewIncomingContext(context.Background(),
-				metadata.Pairs(algorithm.AlgoTypeKey, "python", python.PyRuntimeKey, python.PyRuntime),
-			)
-
-			if tc.ctxSetup != nil {
-				ctx = tc.ctxSetup(ctx)
-			}
-
-			sm := new(smmocks.StateMachine)
-			sm.On("Start", ctx).Return(nil)
-			sm.On("GetState").Return(tc.state)
-			sm.On("SendEvent", mock.Anything).Return()
-
-			svc := &agentService{
-				sm:            sm,
-				eventSvc:      events,
-				quoteProvider: qp,
-				computation:   testComputation(t),
-			}
-
-			go func() {
-				if err := svc.sm.Start(ctx); err != nil {
-					t.Errorf("Error starting state machine: %v", err)
-				}
-			}()
-			tc.setup(svc)
-			_, err := svc.Result(ctx)
-			t.Cleanup(func() {
-				_ = os.RemoveAll("datasets")
-				_ = os.RemoveAll("results")
-			})
-			assert.ErrorIs(t, err, tc.err, "expected %v, got %v", tc.err, err)
-		})
-	}
-}
-
-func TestAttestation(t *testing.T) {
-	events := new(mocks.Service)
-	qp := new(mocks2.QuoteProvider)
-
-	evCall := events.On("SendEvent", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	defer evCall.Unset()
-
-	cases := []struct {
-		name       string
-		reportData [ReportDataSize]byte
-		rawQuote   []uint8
-		err        error
-	}{
-		{
-			name:       "Test attestation successful",
-			reportData: generateReportData(),
-			rawQuote:   make([]uint8, 0),
-			err:        nil,
-		},
-		{
-			name:       "Test attestation failed",
-			reportData: generateReportData(),
-			rawQuote:   nil,
-			err:        ErrAttestationFailed,
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := metadata.NewIncomingContext(context.Background(),
-				metadata.Pairs(algorithm.AlgoTypeKey, "python", python.PyRuntimeKey, python.PyRuntime),
-			)
-			ctx, cancel := context.WithCancel(ctx)
-			defer cancel()
-
-			getQuote := qp.On("GetRawQuote", mock.Anything).Return(tc.rawQuote, tc.err)
-			if tc.err != ErrAttestationFailed {
-				getQuote = qp.On("GetRawQuote", mock.Anything).Return(tc.reportData, nil)
-			}
-			defer getQuote.Unset()
-
-			svc := New(ctx, mglog.NewMock(), events, testComputation(t), qp)
-			time.Sleep(300 * time.Millisecond)
-			_, err := svc.Attestation(ctx, tc.reportData)
-			assert.True(t, errors.Contains(err, tc.err), "expected %v, got %v", tc.err, err)
-		})
-	}
-}
-
-func generateReportData() [ReportDataSize]byte {
-	bytes := make([]byte, ReportDataSize)
-	_, err := rand.Read(bytes)
-	if err != nil {
-		log.Fatalf("Failed to generate random bytes: %v", err)
-	}
-	return [64]byte(bytes)
-}
-
-func testComputation(t *testing.T) Computation {
-	algo, err := os.ReadFile(algoPath)
-	require.NoError(t, err)
-
-	algoHash := sha3.Sum256(algo)
-
-	data, err := os.ReadFile(dataPath)
-	require.NoError(t, err)
-
-	dataHash := sha3.Sum256(data)
-
-	return Computation{
-		ID:              "1",
-		Name:            "sample computation",
-		Description:     "sample description",
-		Datasets:        []Dataset{{Hash: dataHash, UserKey: []byte("key"), Dataset: data, Filename: datasetFile}},
-		Algorithm:       Algorithm{Hash: algoHash, UserKey: []byte("key"), Algorithm: algo},
-		ResultConsumers: []ResultConsumer{{UserKey: []byte("key")}},
-		AgentConfig: AgentConfig{
-			Port:        "7002",
-			LogLevel:    "debug",
-			AttestedTls: false,
-		},
-	}
-}
@@ -0,0 +1,117 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package agent
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"sync"
+)
+
+//go:generate stringer -type=state
+type state int
+
+const (
+	idle state = iota
+	receivingManifests
+	receivingAlgorithms
+	receivingData
+	running
+	resultsReady
+	complete
+)
+
+type event int
+
+const (
+	start event = iota
+	manifestsReceived
+	algorithmsReceived
+	dataReceived
+	runComplete
+	resultsConsumed
+)
+
+// StateMachine represents the state machine.
+type StateMachine struct {
+	mu             sync.Mutex
+	State          state
+	EventChan      chan event
+	Transitions    map[state]map[event]state
+	StateFunctions map[state]func()
+	logger         *slog.Logger
+}
+
+// NewStateMachine creates a new StateMachine.
+func NewStateMachine(logger *slog.Logger) *StateMachine {
+	sm := &StateMachine{
+		State:          idle,
+		EventChan:      make(chan event),
+		Transitions:    make(map[state]map[event]state),
+		StateFunctions: make(map[state]func()),
+		logger:         logger,
+	}
+
+	sm.Transitions[idle] = make(map[event]state)
+	sm.Transitions[idle][start] = receivingManifests
+
+	sm.Transitions[receivingManifests] = make(map[event]state)
+	sm.Transitions[receivingManifests][manifestsReceived] = receivingAlgorithms
+
+	sm.Transitions[receivingAlgorithms] = make(map[event]state)
+	sm.Transitions[receivingAlgorithms][algorithmsReceived] = receivingData
+
+	sm.Transitions[receivingData] = make(map[event]state)
+	sm.Transitions[receivingData][dataReceived] = running
+
+	sm.Transitions[running] = make(map[event]state)
+	sm.Transitions[running][runComplete] = resultsReady
+
+	sm.Transitions[resultsReady] = make(map[event]state)
+	sm.Transitions[resultsReady][resultsConsumed] = complete
+
+	return sm
+}
+
+// Start the state machine.
+func (sm *StateMachine) Start(ctx context.Context) {
+	for {
+		select {
+		case event := <-sm.EventChan:
+			nextState, valid := sm.Transitions[sm.GetState()][event]
+			if valid {
+				sm.mu.Lock()
+				sm.State = nextState
+				sm.mu.Unlock()
+				sm.logger.Debug(fmt.Sprintf("Transition: %v -> %v\n", sm.GetState(), nextState))
+			} else {
+				sm.logger.Error(fmt.Sprintf("Invalid transition: %v -> ???\n", sm.GetState()))
+			}
+			stateFunc, exists := sm.StateFunctions[sm.GetState()]
+			if exists {
+				go stateFunc()
+			}
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// SendEvent sends an event to the state machine.
+func (sm *StateMachine) SendEvent(event event) {
+	sm.EventChan <- event
+}
+
+func (sm *StateMachine) GetState() state {
+	sm.mu.Lock()
+	state := sm.State
+	sm.mu.Unlock()
+	return state
+}
+
+func (sm *StateMachine) SetState(state state) {
+	sm.mu.Lock()
+	sm.State = state
+	sm.mu.Unlock()
+}
@@ -0,0 +1,29 @@
+// Code generated by "stringer -type=state"; DO NOT EDIT.
+
+package agent
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[idle-0]
+	_ = x[receivingManifests-1]
+	_ = x[receivingAlgorithms-2]
+	_ = x[receivingData-3]
+	_ = x[running-4]
+	_ = x[resultsReady-5]
+	_ = x[complete-6]
+}
+
+const _state_name = "idlereceivingManifestsreceivingAlgorithmsreceivingDatarunningresultsReadycomplete"
+
+var _state_index = [...]uint8{0, 4, 22, 41, 54, 61, 73, 81}
+
+func (i state) String() string {
+	if i < 0 || i >= state(len(_state_index)-1) {
+		return "state(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _state_name[_state_index[i]:_state_index[i+1]]
+}
@@ -4,249 +4,60 @@ package agent

 import (
 	"context"
-	sync "sync"
+	"fmt"
 	"testing"
-	"time"

-	"github.com/ultravioletrs/cocos/agent/statemachine"
+	mglog "github.com/absmach/magistrala/logger"
 )

-type MockState int
-
-type MockEvent int
-
-func (s MockState) String() string {
-	return []string{"State1", "State2", "State3"}[s]
-}
-
-func (e MockEvent) String() string {
-	return []string{"Event1", "Event2", "Event3"}[e]
-}
-
-const (
-	State1 MockState = iota
-	State2
-	State3
-)
-
-const (
-	Event1 MockEvent = iota
-	Event2
-	Event3
-)
-
-func TestNewStateMachine(t *testing.T) {
-	sm := statemachine.NewStateMachine(State1)
-	if sm == nil {
-		t.Fatal("NewStateMachine returned nil")
-	}
-	if sm.GetState() != State1 {
-		t.Errorf("Initial state not set correctly, got %v, want %v", sm.GetState(), State1)
-	}
-}
-
-func TestAddTransition(t *testing.T) {
-	sm := statemachine.NewStateMachine(State1)
-	sm.AddTransition(statemachine.Transition{From: State1, Event: Event1, To: State2})
-
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	go func() {
-		if err := sm.Start(ctx); err != context.Canceled {
-			t.Errorf("Start returned error: %v", err)
-		}
-	}()
-
-	sm.SendEvent(Event1)
-
-	time.Sleep(50 * time.Millisecond)
-
-	if sm.GetState() != State2 {
-		t.Errorf("Transition not applied correctly, got state %v, want %v", sm.GetState(), State2)
-	}
-}
-
-func TestSetAction(t *testing.T) {
-	sm := statemachine.NewStateMachine(State1)
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	sm.SetAction(State2, func(s statemachine.State) {
-		defer wg.Done()
-	})
-
-	sm.AddTransition(statemachine.Transition{From: State1, Event: Event1, To: State2})
-
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	go func() {
-		if err := sm.Start(ctx); err != context.Canceled {
-			t.Errorf("Start returned error: %v", err)
-		}
-	}()
-
-	sm.SendEvent(Event1)
-
-	wg.Wait()
-
-	if ctx.Err() != nil {
-		t.Error("Action was not called within the expected time")
-	}
-}
-
-func TestInvalidTransition(t *testing.T) {
-	sm := statemachine.NewStateMachine(State1)
-	sm.AddTransition(statemachine.Transition{From: State1, Event: Event1, To: State2})
-
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	errChan := make(chan error)
-	go func() {
-		errChan <- sm.Start(ctx)
-	}()
-
-	sm.SendEvent(Event2)
-
-	select {
-	case err := <-errChan:
-		if err == nil {
-			t.Errorf("Expected invalid transition error, got: %v", err)
-		}
-	case <-time.After(150 * time.Millisecond):
-		t.Error("Timeout waiting for invalid transition error")
-	}
-}
-
-func TestMultipleTransitions(t *testing.T) {
-	sm := statemachine.NewStateMachine(State1)
-	sm.AddTransition(statemachine.Transition{From: State1, Event: Event1, To: State2})
-	sm.AddTransition(statemachine.Transition{From: State2, Event: Event2, To: State3})
-	sm.AddTransition(statemachine.Transition{From: State3, Event: Event3, To: State1})
-
-	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
-	defer cancel()
-
-	go func() {
-		if err := sm.Start(ctx); err != context.Canceled {
-			t.Errorf("Start returned error: %v", err)
-		}
-	}()
-
-	transitions := []struct {
-		event MockEvent
-		want  MockState
+func TestStateMachineTransitions(t *testing.T) {
+	testCases := []struct {
+		fromState state
+		event     event
+		expected  state
 	}{
-		{Event1, State2},
-		{Event2, State3},
-		{Event3, State1},
+		{idle, start, receivingManifests},
+		{receivingManifests, manifestsReceived, receivingAlgorithms},
+		{receivingAlgorithms, algorithmsReceived, receivingData},
+		{receivingData, dataReceived, running},
+		{running, runComplete, resultsReady},
+		{resultsReady, resultsConsumed, complete},
 	}

-	for _, tt := range transitions {
-		sm.SendEvent(tt.event)
-		time.Sleep(50 * time.Millisecond)
+	for _, testCase := range testCases {
+		t.Run(fmt.Sprintf("Transition from %v to %v", testCase.fromState, testCase.expected), func(t *testing.T) {
+			sm := NewStateMachine(mglog.NewMock())
+			done := make(chan struct{})
+			ctx, cancel := context.WithCancel(context.Background())
+			go func() {
+				sm.Start(ctx)
+				close(done)
+			}()
+			sm.SetState(testCase.fromState)

-		if sm.GetState() != tt.want {
-			t.Errorf("After event %v, got state %v, want %v", tt.event, sm.GetState(), tt.want)
-		}
+			sm.SendEvent(testCase.event)
+
+			if sm.GetState() != testCase.expected {
+				t.Errorf("Expected state %v after the event, but got %v", testCase.expected, sm.GetState())
+			}
+			close(sm.EventChan)
+			cancel()
+			<-done
+		})
 	}
 }

-func TestConcurrency(t *testing.T) {
-	sm := statemachine.NewStateMachine(State1)
-	sm.AddTransition(statemachine.Transition{From: State1, Event: Event1, To: State2})
-	sm.AddTransition(statemachine.Transition{From: State2, Event: Event2, To: State1})
+func TestStateMachineInvalidTransition(t *testing.T) {
+	sm := NewStateMachine(mglog.NewMock())
+	ctx, cancel := context.WithCancel(context.Background())
+	go sm.Start(ctx)

-	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
-	defer cancel()
+	sm.SetState(idle)

-	go func() {
-		if err := sm.Start(ctx); err == nil {
-			t.Errorf("Expected context error, got nil")
-		}
-	}()
+	sm.SendEvent(dataReceived)

-	for i := 0; i < 100; i++ {
-		go func() {
-			sm.SendEvent(Event1)
-			sm.SendEvent(Event2)
-		}()
-	}
-
-	time.Sleep(400 * time.Millisecond)
-
-	finalState := sm.GetState()
-	if finalState != State1 && finalState != State2 {
-		t.Errorf("Unexpected final state: %v", finalState)
-	}
-}
-
-func TestAgentEventString(t *testing.T) {
-	tests := []struct {
-		event AgentEvent
-		want  string
-	}{
-		{Start, "Start"},
-		{ManifestReceived, "ManifestReceived"},
-		{AlgorithmReceived, "AlgorithmReceived"},
-		{DataReceived, "DataReceived"},
-		{RunComplete, "RunComplete"},
-		{ResultsConsumed, "ResultsConsumed"},
-		{RunFailed, "RunFailed"},
-		{AgentEvent(-1), "AgentEvent(-1)"},
-	}
-
-	for _, tt := range tests {
-		if got := tt.event.String(); got != tt.want {
-			t.Errorf("AgentEvent.String() = %v, want %v", got, tt.want)
-		}
-	}
-}
-
-func TestAgentStateString(t *testing.T) {
-	tests := []struct {
-		state AgentState
-		want  string
-	}{
-		{Idle, "Idle"},
-		{ReceivingManifest, "ReceivingManifest"},
-		{ReceivingAlgorithm, "ReceivingAlgorithm"},
-		{ReceivingData, "ReceivingData"},
-		{Running, "Running"},
-		{ConsumingResults, "ConsumingResults"},
-		{Complete, "Complete"},
-		{Failed, "Failed"},
-		{AgentState(-1), "AgentState(-1)"},
-	}
-
-	for _, tt := range tests {
-		if got := tt.state.String(); got != tt.want {
-			t.Errorf("AgentState.String() = %v, want %v", got, tt.want)
-		}
-	}
-}
-
-func TestStatusString(t *testing.T) {
-	tests := []struct {
-		status Status
-		want   string
-	}{
-		{IdleState, "IdleState"},
-		{InProgress, "InProgress"},
-		{Ready, "Ready"},
-		{Completed, "Completed"},
-		{Terminated, "Terminated"},
-		{Warning, "Warning"},
-		{Starting, "Starting"},
-		{Status(uint8(8)), "Status(8)"},
-	}
-
-	for _, tt := range tests {
-		if got := tt.status.String(); got != tt.want {
-			t.Errorf("Status.String() = %v, want %v", got, tt.want)
-		}
+	if sm.State != idle {
+		t.Errorf("State should not change on an invalid event, but got %v", sm.State)
 	}
+	cancel()
 }
@@ -1,233 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-// Code generated by mockery v2.43.2. DO NOT EDIT.
-
-package mocks
-
-import (
-	context "context"
-
-	mock "github.com/stretchr/testify/mock"
-	statemachine "github.com/ultravioletrs/cocos/agent/statemachine"
-)
-
-// StateMachine is an autogenerated mock type for the StateMachine type
-type StateMachine struct {
-	mock.Mock
-}
-
-type StateMachine_Expecter struct {
-	mock *mock.Mock
-}
-
-func (_m *StateMachine) EXPECT() *StateMachine_Expecter {
-	return &StateMachine_Expecter{mock: &_m.Mock}
-}
-
-// AddTransition provides a mock function with given fields: t
-func (_m *StateMachine) AddTransition(t statemachine.Transition) {
-	_m.Called(t)
-}
-
-// StateMachine_AddTransition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTransition'
-type StateMachine_AddTransition_Call struct {
-	*mock.Call
-}
-
-// AddTransition is a helper method to define mock.On call
-//   - t statemachine.Transition
-func (_e *StateMachine_Expecter) AddTransition(t interface{}) *StateMachine_AddTransition_Call {
-	return &StateMachine_AddTransition_Call{Call: _e.mock.On("AddTransition", t)}
-}
-
-func (_c *StateMachine_AddTransition_Call) Run(run func(t statemachine.Transition)) *StateMachine_AddTransition_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(statemachine.Transition))
-	})
-	return _c
-}
-
-func (_c *StateMachine_AddTransition_Call) Return() *StateMachine_AddTransition_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *StateMachine_AddTransition_Call) RunAndReturn(run func(statemachine.Transition)) *StateMachine_AddTransition_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// GetState provides a mock function with given fields:
-func (_m *StateMachine) GetState() statemachine.State {
-	ret := _m.Called()
-
-	if len(ret) == 0 {
-		panic("no return value specified for GetState")
-	}
-
-	var r0 statemachine.State
-	if rf, ok := ret.Get(0).(func() statemachine.State); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(statemachine.State)
-		}
-	}
-
-	return r0
-}
-
-// StateMachine_GetState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetState'
-type StateMachine_GetState_Call struct {
-	*mock.Call
-}
-
-// GetState is a helper method to define mock.On call
-func (_e *StateMachine_Expecter) GetState() *StateMachine_GetState_Call {
-	return &StateMachine_GetState_Call{Call: _e.mock.On("GetState")}
-}
-
-func (_c *StateMachine_GetState_Call) Run(run func()) *StateMachine_GetState_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run()
-	})
-	return _c
-}
-
-func (_c *StateMachine_GetState_Call) Return(_a0 statemachine.State) *StateMachine_GetState_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StateMachine_GetState_Call) RunAndReturn(run func() statemachine.State) *StateMachine_GetState_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SendEvent provides a mock function with given fields: event
-func (_m *StateMachine) SendEvent(event statemachine.Event) {
-	_m.Called(event)
-}
-
-// StateMachine_SendEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendEvent'
-type StateMachine_SendEvent_Call struct {
-	*mock.Call
-}
-
-// SendEvent is a helper method to define mock.On call
-//   - event statemachine.Event
-func (_e *StateMachine_Expecter) SendEvent(event interface{}) *StateMachine_SendEvent_Call {
-	return &StateMachine_SendEvent_Call{Call: _e.mock.On("SendEvent", event)}
-}
-
-func (_c *StateMachine_SendEvent_Call) Run(run func(event statemachine.Event)) *StateMachine_SendEvent_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(statemachine.Event))
-	})
-	return _c
-}
-
-func (_c *StateMachine_SendEvent_Call) Return() *StateMachine_SendEvent_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *StateMachine_SendEvent_Call) RunAndReturn(run func(statemachine.Event)) *StateMachine_SendEvent_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// SetAction provides a mock function with given fields: state, action
-func (_m *StateMachine) SetAction(state statemachine.State, action statemachine.Action) {
-	_m.Called(state, action)
-}
-
-// StateMachine_SetAction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAction'
-type StateMachine_SetAction_Call struct {
-	*mock.Call
-}
-
-// SetAction is a helper method to define mock.On call
-//   - state statemachine.State
-//   - action statemachine.Action
-func (_e *StateMachine_Expecter) SetAction(state interface{}, action interface{}) *StateMachine_SetAction_Call {
-	return &StateMachine_SetAction_Call{Call: _e.mock.On("SetAction", state, action)}
-}
-
-func (_c *StateMachine_SetAction_Call) Run(run func(state statemachine.State, action statemachine.Action)) *StateMachine_SetAction_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(statemachine.State), args[1].(statemachine.Action))
-	})
-	return _c
-}
-
-func (_c *StateMachine_SetAction_Call) Return() *StateMachine_SetAction_Call {
-	_c.Call.Return()
-	return _c
-}
-
-func (_c *StateMachine_SetAction_Call) RunAndReturn(run func(statemachine.State, statemachine.Action)) *StateMachine_SetAction_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// Start provides a mock function with given fields: ctx
-func (_m *StateMachine) Start(ctx context.Context) error {
-	ret := _m.Called(ctx)
-
-	if len(ret) == 0 {
-		panic("no return value specified for Start")
-	}
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(ctx)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// StateMachine_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
-type StateMachine_Start_Call struct {
-	*mock.Call
-}
-
-// Start is a helper method to define mock.On call
-//   - ctx context.Context
-func (_e *StateMachine_Expecter) Start(ctx interface{}) *StateMachine_Start_Call {
-	return &StateMachine_Start_Call{Call: _e.mock.On("Start", ctx)}
-}
-
-func (_c *StateMachine_Start_Call) Run(run func(ctx context.Context)) *StateMachine_Start_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context))
-	})
-	return _c
-}
-
-func (_c *StateMachine_Start_Call) Return(_a0 error) *StateMachine_Start_Call {
-	_c.Call.Return(_a0)
-	return _c
-}
-
-func (_c *StateMachine_Start_Call) RunAndReturn(run func(context.Context) error) *StateMachine_Start_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
-// NewStateMachine creates a new instance of StateMachine. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-// The first argument is typically a *testing.T value.
-func NewStateMachine(t interface {
-	mock.TestingT
-	Cleanup(func())
-}) *StateMachine {
-	mock := &StateMachine{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
@@ -1,112 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package statemachine
-
-import (
-	"context"
-	"fmt"
-	"sync"
-)
-
-type State interface {
-	String() string
-}
-
-type Event interface {
-	String() string
-}
-
-type Action func(State)
-
-type Transition struct {
-	From  State
-	Event Event
-	To    State
-}
-
-type StateMachine interface {
-	AddTransition(t Transition)
-	SetAction(state State, action Action)
-	GetState() State
-	SendEvent(event Event)
-	Start(ctx context.Context) error
-}
-
-type stateMachine struct {
-	mu           sync.Mutex
-	currentState State
-	transitions  map[State]map[Event]State
-	actions      map[State]Action
-	eventChan    chan Event
-}
-
-func NewStateMachine(initialState State) StateMachine {
-	return &stateMachine{
-		currentState: initialState,
-		transitions:  make(map[State]map[Event]State),
-		actions:      make(map[State]Action),
-		eventChan:    make(chan Event),
-	}
-}
-
-func (sm *stateMachine) AddTransition(t Transition) {
-	sm.mu.Lock()
-	defer sm.mu.Unlock()
-
-	if _, ok := sm.transitions[t.From]; !ok {
-		sm.transitions[t.From] = make(map[Event]State)
-	}
-	sm.transitions[t.From][t.Event] = t.To
-}
-
-func (sm *stateMachine) SetAction(state State, action Action) {
-	sm.mu.Lock()
-	defer sm.mu.Unlock()
-
-	sm.actions[state] = action
-}
-
-func (sm *stateMachine) GetState() State {
-	sm.mu.Lock()
-	defer sm.mu.Unlock()
-	return sm.currentState
-}
-
-func (sm *stateMachine) SendEvent(event Event) {
-	sm.eventChan <- event
-}
-
-func (sm *stateMachine) Start(ctx context.Context) error {
-	for {
-		select {
-		case event := <-sm.eventChan:
-			if err := sm.handleEvent(event); err != nil {
-				return err
-			}
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-}
-
-func (sm *stateMachine) handleEvent(event Event) error {
-	sm.mu.Lock()
-	currentState := sm.currentState
-	nextState, valid := sm.transitions[currentState][event]
-	sm.mu.Unlock()
-
-	if !valid {
-		return fmt.Errorf("invalid transition: %v -> %v", currentState, event)
-	}
-
-	sm.mu.Lock()
-	sm.currentState = nextState
-	action := sm.actions[nextState]
-	sm.mu.Unlock()
-
-	if action != nil {
-		go action(nextState)
-	}
-
-	return nil
-}
@@ -1,29 +0,0 @@
-// Code generated by "stringer -type=Status"; DO NOT EDIT.
-
-package agent
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[IdleState-0]
-	_ = x[InProgress-1]
-	_ = x[Ready-2]
-	_ = x[Completed-3]
-	_ = x[Terminated-4]
-	_ = x[Warning-5]
-	_ = x[Starting-6]
-}
-
-const _Status_name = "IdleStateInProgressReadyCompletedTerminatedWarningStarting"
-
-var _Status_index = [...]uint8{0, 9, 19, 24, 33, 43, 50, 58}
-
-func (i Status) String() string {
-	if i >= Status(len(_Status_index)-1) {
-		return "Status(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _Status_name[_Status_index[i]:_Status_index[i+1]]
-}
@@ -1,12 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-//go:build embed
-// +build embed
-
-package cocosai
-
-import _ "embed"
-
-//go:embed attestation.bin
-var EmbeddedAttestation []byte
@@ -1,6 +1,6 @@
 # Agent CLI

-This repository contains the command-line interface (CLI) tool for interacting with the Agent and manager service. The CLI allows you to perform various tasks such as running computations, uploading algorithm and datasets, and retrieving results.
+This repository contains the command-line interface (CLI) tool for interacting with the Agent and manager service. The CLI allows you to perform various tasks such as running computations, uploading algorithms and datasets, and retrieving results.

 ## Build

@@ -12,18 +12,26 @@ make cli

 ## Usage

+#### Run Computation
+
+To run a computation, use the following command:
+
+```bash
+./build/cocos-cli manager run --computation '{"name": "my-computation"}'
+```
+
 #### Get attestation
 Retrieves attestation information from the SEV guest and saves it to a file.
 To retrieve attestation from agent, use the following command:
 ```bash
-./build/cocos-cli attestation get '<report_data>'
+./build/cocos-cli agent attestation get '<report_data>'
 ```

 #### Validate attestation
 Validates the retrieved attestation information against a specified policy and checks its authenticity.
 To validate and verify attestation from agent, use the following command:
 ```bash
-./build/cocos-cli attestation validate '<attestation>' --report_data '<report_data>'
+./build/cocos-cli agent attestation validate '<attestation>' --report_data '<report_data>'
 ```
 ##### Flags
 - --config: Path to a JSON file containing the validation configuration. This can be used to override individual flags.
@@ -62,41 +70,21 @@ To validate and verify attestation from agent, use the following command:
 To upload an algorithm, use the following command:

 ```bash
-./build/cocos-cli algo /path/to/algorithm <private_key_file_path>
+./build/cocos-cli agent algo /path/to/algorithm
 ```

-##### Flags
- -a, --algorithm string        Algorithm type to run (default "bin")
-     --args stringArray        Arguments to pass to the algorithm
-     --python-runtime string   Python runtime to use (default "python3")
- -r, --requirements string     Python requirements file
-
 #### Upload Dataset

 To upload a dataset, use the following command:

 ```bash
-./build/cocos-cli data /path/to/dataset.csv <private_key_file_path>
+./build/cocos-cli agent data /path/to/dataset.csv
 ```

-Users can also upload directories which will be compressed on transit. Once received by agent they will be stored as compressed files or decompressed if the user passed the decompression argument.
-
-##### Flags
- -d, --decompress   Decompress the dataset on agent
-
-
-
 #### Retrieve result

 To retrieve the computation result, use the following command:

 ```bash
-./build/cocos-cli result <private_key_file_path>
-```
-
-#### Checksum
-When defining the manifest dataset and algorithm checksums are required. This can be done as below:
-
-```bash
-./build/cocos-cli checksum <path_to_dataset_or_algorithm>
-```
+./build/cocos-cli agent result
+```
@@ -1,180 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"bytes"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/pkg/sdk/mocks"
-)
-
-const algorithmFile = "test_algo_file.py"
-
-func generateRSAPrivateKeyFile(fileName string) error {
-	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return err
-	}
-
-	privKeyFile, err := os.Create(fileName)
-	if err != nil {
-		return err
-	}
-	defer privKeyFile.Close()
-
-	privateKeyPEM := &pem.Block{
-		Type:  rsaKeyType,
-		Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
-	}
-
-	err = pem.Encode(privKeyFile, privateKeyPEM)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func TestAlgorithmCmd(t *testing.T) {
-	tests := []struct {
-		name           string
-		setupMock      func(*mocks.SDK)
-		setupFiles     func() error
-		args           []string
-		connectErr     error
-		expectedOutput string
-		cleanup        func()
-	}{
-		{
-			name: "successful upload",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Algo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() error {
-				if err := os.WriteFile(algorithmFile, []byte("test algorithm"), 0o644); err != nil {
-					return err
-				}
-				return generateRSAPrivateKeyFile(privateKeyFile)
-			},
-			args:           []string{algorithmFile, privateKeyFile},
-			expectedOutput: "Successfully uploaded algorithm",
-			cleanup: func() {
-				os.Remove(privateKeyFile)
-				os.Remove(algorithmFile)
-			},
-		},
-		{
-			name: "missing algorithm file",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Algo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			args:           []string{"non_existent_algo_file.py", privateKeyFile},
-			expectedOutput: "Error reading algorithm file",
-		},
-		{
-			name: "missing private key file",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Algo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() error {
-				return os.WriteFile(algorithmFile, []byte("test algorithm"), 0o644)
-			},
-			args:           []string{algorithmFile, "non_existent_private_key.pem"},
-			expectedOutput: "Error reading private key file",
-			cleanup: func() {
-				os.Remove(algorithmFile)
-			},
-		},
-		{
-			name: "upload failure",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Algo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("failed to upload algorithm due to error"))
-			},
-			setupFiles: func() error {
-				if err := os.WriteFile(algorithmFile, []byte("test algorithm"), 0o644); err != nil {
-					return err
-				}
-				return generateRSAPrivateKeyFile(privateKeyFile)
-			},
-			args:           []string{algorithmFile, privateKeyFile},
-			expectedOutput: "Failed to upload algorithm",
-			cleanup: func() {
-				os.Remove(privateKeyFile)
-				os.Remove(algorithmFile)
-			},
-		},
-		{
-			name: "invalid private key",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Algo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() error {
-				if err := os.WriteFile(algorithmFile, []byte("test algorithm"), 0o644); err != nil {
-					return err
-				}
-				privKeyFile, err := os.Create(privateKeyFile)
-				if err != nil {
-					return err
-				}
-				defer privKeyFile.Close()
-				_, err = privKeyFile.WriteString("invalid private key")
-				return err
-			},
-			args:           []string{algorithmFile, privateKeyFile},
-			expectedOutput: "Error decoding private key",
-			cleanup: func() {
-				os.Remove(algorithmFile)
-				os.Remove(privateKeyFile)
-			},
-		},
-		{
-			name: "connection error",
-			setupMock: func(m *mocks.SDK) {
-			},
-			connectErr:     errors.New("failed to connect to agent"),
-			args:           []string{algorithmFile, privateKeyFile},
-			expectedOutput: "Failed to connect to agent",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockSDK := new(mocks.SDK)
-			if tt.setupMock != nil {
-				tt.setupMock(mockSDK)
-			}
-
-			testCLI := CLI{
-				agentSDK:   mockSDK,
-				connectErr: tt.connectErr,
-			}
-
-			if tt.setupFiles != nil {
-				err := tt.setupFiles()
-				require.NoError(t, err)
-			}
-
-			cmd := testCLI.NewAlgorithmCmd()
-			buf := new(bytes.Buffer)
-			cmd.SetOut(buf)
-			cmd.SetArgs(tt.args)
-			err := cmd.Execute()
-			require.NoError(t, err)
-
-			require.Contains(t, buf.String(), tt.expectedOutput)
-
-			if tt.cleanup != nil {
-				tt.cleanup()
-			}
-		})
-	}
-}
@@ -3,94 +3,40 @@
 package cli

 import (
-	"context"
-	"encoding/pem"
+	"log"
 	"os"

-	"github.com/fatih/color"
 	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/agent/algorithm"
-	"github.com/ultravioletrs/cocos/agent/algorithm/python"
-	"google.golang.org/grpc/metadata"
+	"github.com/ultravioletrs/cocos/agent"
 )

-var (
-	pythonRuntime    string
-	algoType         string
-	requirementsFile string
-	algoArgs         []string
-)
-
-func (cli *CLI) NewAlgorithmCmd() *cobra.Command {
-	cmd := &cobra.Command{
+func (cli *CLI) NewAlgorithmsCmd() *cobra.Command {
+	return &cobra.Command{
 		Use:     "algo",
 		Short:   "Upload an algorithm binary",
-		Example: "algo <algo_file> <private_key_file_path>",
-		Args:    cobra.ExactArgs(2),
+		Example: "algo <algo_file> <id> <provider>",
+		Args:    cobra.ExactArgs(3),
 		Run: func(cmd *cobra.Command, args []string) {
-			if cli.connectErr != nil {
-				printError(cmd, "Failed to connect to agent: %v ❌ ", cli.connectErr)
-				return
-			}
-
 			algorithmFile := args[0]

-			cmd.Println("Uploading algorithm file:", algorithmFile)
+			log.Println("Uploading algorithm binary:", algorithmFile)

-			algorithm, err := os.Open(algorithmFile)
+			algorithm, err := os.ReadFile(algorithmFile)
 			if err != nil {
-				printError(cmd, "Error reading algorithm file: %v ❌ ", err)
-				return
+				log.Fatalf("Error reading algorithm file: %v", err)
 			}

-			defer algorithm.Close()
-
-			var req *os.File
-			if requirementsFile != "" {
-				req, err = os.Open(requirementsFile)
-				if err != nil {
-					printError(cmd, "Error reading requirments file: %v ❌ ", err)
-					return
-				}
-				defer req.Close()
+			algoReq := agent.Algorithm{
+				Algorithm: algorithm,
+				ID:        args[1],
+				Provider:  args[2],
 			}

-			privKeyFile, err := os.ReadFile(args[1])
-			if err != nil {
-				printError(cmd, "Error reading private key file: %v ❌ ", err)
-				return
+			if err := cli.agentSDK.Algo(cmd.Context(), algoReq); err != nil {
+				log.Fatalf("Error uploading algorithm with ID %s and provider %s: %v", algoReq.ID, algoReq.Provider, err)
 			}

-			pemBlock, _ := pem.Decode(privKeyFile)
-
-			privKey, err := decodeKey(pemBlock)
-			if err != nil {
-				printError(cmd, "Error decoding private key: %v ❌ ", err)
-				return
-			}
-
-			ctx := metadata.NewOutgoingContext(cmd.Context(), metadata.New(make(map[string]string)))
-
-			if err := cli.agentSDK.Algo(addAlgoMetadata(ctx), algorithm, req, privKey); err != nil {
-				printError(cmd, "Failed to upload algorithm due to error: %v ❌ ", err)
-				return
-			}
-
-			cmd.Println(color.New(color.FgGreen).Sprint("Successfully uploaded algorithm! ✔ "))
+			log.Println("Successfully uploaded algorithm")
 		},
 	}
-
-	cmd.Flags().StringVarP(&algoType, "algorithm", "a", string(algorithm.AlgoTypeBin), "Algorithm type to run")
-	cmd.Flags().StringVar(&pythonRuntime, "python-runtime", python.PyRuntime, "Python runtime to use")
-	cmd.Flags().StringVarP(&requirementsFile, "requirements", "r", "", "Python requirements file")
-	cmd.Flags().StringArrayVar(&algoArgs, "args", []string{}, "Arguments to pass to the algorithm")
-
-	return cmd
-}
-
-func addAlgoMetadata(ctx context.Context) context.Context {
-	ctx = algorithm.AlgorithmTypeToContext(ctx, algoType)
-	ctx = algorithm.AlgorithmArgsToContext(ctx, algoArgs)
-	ctx = python.PythonRunTimeToContext(ctx, pythonRuntime)
-	return ctx
 }
@@ -4,23 +4,21 @@ package cli

 import (
 	"encoding/hex"
-	"encoding/json"
 	"fmt"
+	"log"
 	"os"
 	"strconv"
 	"strings"
 	"time"

-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/fatih/color"
 	"github.com/google/go-sev-guest/abi"
 	"github.com/google/go-sev-guest/proto/check"
-	"github.com/google/go-sev-guest/proto/sevsnp"
-	"github.com/google/go-sev-guest/tools/lib/report"
+	"github.com/google/go-sev-guest/validate"
+	"github.com/google/go-sev-guest/verify"
+	"github.com/google/go-sev-guest/verify/trust"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/pkg/attestation/quoteprovider"
 	"google.golang.org/protobuf/encoding/protojson"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 )
@@ -42,9 +40,6 @@ const (
 	size48                  = 48
 	size64                  = 64
 	attestationFilePath     = "attestation.bin"
-	attestationJson         = "attestation.json"
-	sevProductNameMilan     = "Milan"
-	sevProductNameGenoa     = "Genoa"
 	exampleJSONConfig       = `
 	{
 		"rootOfTrust":{
@@ -117,8 +112,6 @@ var (
 	empty32             = [size32]byte{}
 	empty64             = [size64]byte{}
 	defaultReportIdMa   = []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
-	getJsonAttestation  bool
-	errReportSize       = errors.New("attestation contents too small")
 )

 func (cli *CLI) NewAttestationCmd() *cobra.Command {
@@ -126,9 +119,9 @@ func (cli *CLI) NewAttestationCmd() *cobra.Command {
 		Use:   "attestation [command]",
 		Short: "Get and validate attestations",
 		Run: func(cmd *cobra.Command, args []string) {
-			cmd.Printf("Get and validate attestations\n\n")
-			cmd.Printf("Usage:\n  %s [command]\n\n", cmd.CommandPath())
-			cmd.Printf("Available Commands:\n")
+			fmt.Printf("Get and validate attestations\n\n")
+			fmt.Printf("Usage:\n  %s [command]\n\n", cmd.CommandPath())
+			fmt.Printf("Available Commands:\n")

 			// Filter out "completion" command
 			availableCommands := make([]*cobra.Command, 0)
@@ -139,115 +132,47 @@ func (cli *CLI) NewAttestationCmd() *cobra.Command {
 			}

 			for _, subCmd := range availableCommands {
-				cmd.Printf("  %-15s%s\n", subCmd.Name(), subCmd.Short)
+				fmt.Printf("  %-15s%s\n", subCmd.Name(), subCmd.Short)
 			}

-			cmd.Printf("\nFlags:\n")
+			fmt.Printf("\nFlags:\n")
 			cmd.Flags().VisitAll(func(flag *pflag.Flag) {
-				cmd.Printf("  -%s, --%s %s\n", flag.Shorthand, flag.Name, flag.Usage)
+				fmt.Printf("  -%s, --%s %s\n", flag.Shorthand, flag.Name, flag.Usage)
 			})
-			cmd.Printf("\nUse \"%s [command] --help\" for more information about a command.\n", cmd.CommandPath())
+			fmt.Printf("\nUse \"%s [command] --help\" for more information about a command.\n", cmd.CommandPath())
 		},
 	}
 }

 func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:     "get",
 		Short:   "Retrieve attestation information from agent. Report data expected in hex enoded string of length 64 bytes.",
-		Example: "get <report_data>",
+		Example: "report <report_data>",
 		Args:    cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
-			if cli.connectErr != nil {
-				printError(cmd, "Failed to connect to agent: %v ❌ ", cli.connectErr)
-				return
-			}
-
-			cmd.Println("Getting attestation")
+			log.Println("Getting attestation")

 			reportData, err := hex.DecodeString(args[0])
 			if err != nil {
-				printError(cmd, "Error decoding report data: %v ❌ ", err)
-				return
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}
 			if len(reportData) != agent.ReportDataSize {
-				msg := color.New(color.FgRed).Sprintf("report data must be a hex encoded string of length %d bytes ❌ ", agent.ReportDataSize)
-				cmd.Println(msg)
-				return
+				log.Fatalf("report data must be a hex encoded string of length %d bytes", agent.ReportDataSize)
 			}

-			filename := attestationFilePath
-			if getJsonAttestation {
-				filename = attestationJson
-			}
-
-			attestationFile, err := os.Create(filename)
+			result, err := cli.agentSDK.Attestation(cmd.Context(), [agent.ReportDataSize]byte(reportData))
 			if err != nil {
-				printError(cmd, "Error creating attestation file: %v ❌ ", err)
-				return
+				log.Fatalf("Error retrieving attestation: %v", err)
 			}

-			if err := cli.agentSDK.Attestation(cmd.Context(), [agent.ReportDataSize]byte(reportData), attestationFile); err != nil {
-				printError(cmd, "Failed to get attestation due to error: %v ❌ ", err)
-				return
+			if err = os.WriteFile(attestationFilePath, result, 0o644); err != nil {
+				log.Fatalf("Error saving attestation result: %v", err)
 			}

-			if err := attestationFile.Close(); err != nil {
-				printError(cmd, "Error closing attestation file: %v ❌ ", err)
-				return
-			}
-
-			if getJsonAttestation {
-				result, err := os.ReadFile(filename)
-				if err != nil {
-					printError(cmd, "Error reading attestation file: %v ❌ ", err)
-					return
-				}
-
-				result, err = attesationToJSON(result)
-				if err != nil {
-					printError(cmd, "Error converting attestation to json: %v ❌ ", err)
-					return
-				}
-
-				if err := os.WriteFile(filename, result, 0o644); err != nil {
-					printError(cmd, "Error writing attestation file: %v ❌ ", err)
-					return
-				}
-			}
-
-			cmd.Println("Attestation result retrieved and saved successfully!")
+			log.Println("Attestation result retrieved and saved successfully!")
 		},
 	}
-
-	cmd.Flags().BoolVarP(&getJsonAttestation, "json", "j", false, "Get attestation in json format")
-
-	return cmd
-}
-
-func attesationToJSON(report []byte) ([]byte, error) {
-	if len(report) < abi.ReportSize {
-		return nil, errors.Wrap(errReportSize, fmt.Errorf("attestation contents too small (0x%x bytes). Want at least 0x%x bytes", len(report), abi.ReportSize))
-	}
-	attestationPB, err := abi.ReportCertsToProto(report[:abi.ReportSize])
-	if err != nil {
-		return nil, err
-	}
-
-	return json.MarshalIndent(attestationPB, "", "	")
-}
-
-func attesationFromJSON(reportFile []byte) ([]byte, error) {
-	var attestationPB sevsnp.Attestation
-	if err := json.Unmarshal(reportFile, &attestationPB); err != nil {
-		return nil, err
-	}
-
-	return report.Transform(&attestationPB, "bin")
-}
-
-func isFileJSON(filename string) bool {
-	return strings.HasSuffix(filename, ".json")
 }

 func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
@@ -257,45 +182,37 @@ func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
 		Example: "validate <attestation_report_file_path>",
 		Args:    cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
-			cmd.Println("Checking attestation")
+			log.Println("Checking attestation")

 			attestationFile = string(args[0])

 			if err := parseConfig(); err != nil {
-				printError(cmd, "Error parsing config: %v ❌ ", err)
-				return
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}
 			if err := parseHashes(); err != nil {
-				printError(cmd, "Error parsing hashes: %v ❌ ", err)
-				return
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}
 			if err := parseFiles(); err != nil {
-				printError(cmd, "Error parsing files: %v ❌ ", err)
-				return
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}
 			// This format is the attestation report in AMD's specified ABI format, immediately
 			// followed by the certificate table bytes.
 			if len(attestation) < abi.ReportSize {
-				msg := color.New(color.FgRed).Sprintf("attestation contents too small (0x%x bytes). Want at least 0x%x bytes ❌ ", len(attestation), abi.ReportSize)
-				cmd.Println(msg)
-				return
+				log.Fatalf("attestation contents too small (0x%x bytes). Want at least 0x%x bytes", len(attestation), abi.ReportSize)
 			}
 			if err := parseUints(); err != nil {
-				printError(cmd, "Error parsing uints: %v ❌ ", err)
-				return
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}
 			cfg.Policy.Vmpl = wrapperspb.UInt32(0)

 			if err := validateInput(); err != nil {
-				printError(cmd, "Error validating input: %v ❌ ", err)
-				return
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}

-			if err := quoteprovider.VerifyAndValidate(attestation, &cfg); err != nil {
-				printError(cmd, "Attestation validation and verification failed with error: %v ❌ ", err)
-				return
+			if err := verifyAndValidateAttestation(attestation); err != nil {
+				log.Fatalf("attestation validation and verification failed with error: %s", err)
 			}
-			cmd.Println("Attestation validation and verification is successful!")
+			log.Println("Attestation validation and verification is successful!")
 		},
 	}
 	cmd.Flags().StringVar(
@@ -449,7 +366,7 @@ func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
 		"Hex-encoded SHA-384 hash values of trusted identity keys in AMD public key format",
 	)
 	cmd.Flags().StringVar(
-		&cfg.RootOfTrust.ProductLine,
+		&cfg.RootOfTrust.Product,
 		"product",
 		"",
 		"The AMD product name for the chip that generated the attestation report.",
@@ -474,18 +391,40 @@ func (cli *CLI) NewValidateAttestationValidationCmd() *cobra.Command {
 	)

 	if err := cmd.MarkFlagRequired("report_data"); err != nil {
-		printError(cmd, "Failed to mark flag as required: %v ❌ ", err)
-		return nil
-	}
-
-	if err := cmd.MarkFlagRequired("product"); err != nil {
-		printError(cmd, "Failed to mark flag as required: %v ❌ ", err)
-		return nil
+		log.Fatalf("Failed to mark flag as required: %s", err)
 	}

 	return cmd
 }

+func verifyAndValidateAttestation(attestation []byte) error {
+	sopts, err := verify.RootOfTrustToOptions(cfg.RootOfTrust)
+	if err != nil {
+		return err
+	}
+	sopts.Product = cfg.Policy.Product
+	sopts.Getter = &trust.RetryHTTPSGetter{
+		Timeout:       timeout,
+		MaxRetryDelay: maxRetryDelay,
+		Getter:        &trust.SimpleHTTPSGetter{},
+	}
+	attestationPB, err := abi.ReportCertsToProto(attestation)
+	if err != nil {
+		return err
+	}
+	if err = verify.SnpAttestation(attestationPB, sopts); err != nil {
+		return err
+	}
+	opts, err := validate.PolicyToOptions(cfg.Policy)
+	if err != nil {
+		return err
+	}
+	if err = validate.SnpAttestation(attestationPB, opts); err != nil {
+		return err
+	}
+	return nil
+}
+
 // parseConfig decodes config passed as json for check.Config struct.
 // example
 /* {
@@ -580,13 +519,6 @@ func parseFiles() error {
 		return err
 	}
 	attestation = file
-	if isFileJSON(attestationFile) {
-		attestation, err = attesationFromJSON(attestation)
-		if err != nil {
-			return err
-		}
-	}
-
 	for _, path := range trustedAuthorKeys {
 		file, err := os.ReadFile(path)
 		if err != nil {
@@ -652,7 +584,7 @@ func getBase(val string) int {
 }

 func validateInput() error {
-	if len(cfg.RootOfTrust.CabundlePaths) != 0 || len(cfg.RootOfTrust.Cabundles) != 0 && cfg.RootOfTrust.ProductLine == "" {
+	if len(cfg.RootOfTrust.CabundlePaths) != 0 || len(cfg.RootOfTrust.Cabundles) != 0 && cfg.RootOfTrust.Product == "" {
 		return fmt.Errorf("product name must be set if CA bundles are provided")
 	}

@@ -1,140 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"encoding/base64"
-	"fmt"
-	"os"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/google/go-sev-guest/proto/check"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-type fieldType int
-
-const (
-	measurementField fieldType = iota
-	hostDataField
-)
-
-const (
-	// 0o744 file permission gives RWX permission to the user and only the R permission to others.
-	filePermission = 0o744
-	// Length of the expected host data and measurement field in bytes.
-	hostDataLength    = 32
-	measurementLength = 48
-)
-
-var (
-	errDecode                       = errors.New("base64 string could not be decoded")
-	errDataLength                   = errors.New("data does not have an adequate length")
-	errReadingAttestationPolicyFile = errors.New("error while reading the attestation policy file")
-	errUnmarshalJSON                = errors.New("failed to unmarshal json")
-	errMarshalJSON                  = errors.New("failed to marshal json")
-	errWriteFile                    = errors.New("failed to write to file")
-	errAttestationPolicyField       = errors.New("the specified field type does not exist in the attestation policy")
-)
-
-func (cli *CLI) NewAttestationPolicyCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "policy [command]",
-		Short: "Change attestation policy",
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Printf("Change attestation policy\n\n")
-			fmt.Printf("Usage:\n  %s [command]\n\n", cmd.CommandPath())
-			fmt.Printf("Available Commands:\n")
-
-			// Filter out "completion" command
-			availableCommands := make([]*cobra.Command, 0)
-			for _, subCmd := range cmd.Commands() {
-				if subCmd.Name() != "completion" {
-					availableCommands = append(availableCommands, subCmd)
-				}
-			}
-
-			for _, subCmd := range availableCommands {
-				fmt.Printf("  %-15s%s\n", subCmd.Name(), subCmd.Short)
-			}
-
-			fmt.Printf("\nFlags:\n")
-			cmd.Flags().VisitAll(func(flag *pflag.Flag) {
-				fmt.Printf("  -%s, --%s %s\n", flag.Shorthand, flag.Name, flag.Usage)
-			})
-			fmt.Printf("\nUse \"%s [command] --help\" for more information about a command.\n", cmd.CommandPath())
-		},
-	}
-}
-
-func (cli *CLI) NewAddMeasurementCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:     "measurement",
-		Short:   "Add measurement to the attestation policy file. The value should be in base64. The second parameter is attestation_policy.json file",
-		Example: "measurement <measurement> <attestation_policy.json>",
-		Args:    cobra.ExactArgs(2),
-		Run: func(cmd *cobra.Command, args []string) {
-			if err := changeAttestationConfiguration(args[1], args[0], measurementLength, measurementField); err != nil {
-				printError(cmd, "Error could not change measurement data: %v ❌ ", err)
-				return
-			}
-		},
-	}
-}
-
-func (cli *CLI) NewAddHostDataCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:     "hostdata",
-		Short:   "Add host data to the attestation policy file. The value should be in base64. The second parameter is attestation_policy.json file",
-		Example: "hostdata <host-data> <attestation_policy.json>",
-		Args:    cobra.ExactArgs(2),
-		Run: func(cmd *cobra.Command, args []string) {
-			if err := changeAttestationConfiguration(args[1], args[0], hostDataLength, hostDataField); err != nil {
-				printError(cmd, "Error could not change host data: %v ❌ ", err)
-				return
-			}
-		},
-	}
-}
-
-func changeAttestationConfiguration(fileName, base64Data string, expectedLength int, field fieldType) error {
-	data, err := base64.StdEncoding.DecodeString(base64Data)
-	if err != nil {
-		return errDecode
-	}
-
-	if len(data) != expectedLength {
-		return errDataLength
-	}
-
-	ac := check.Config{Policy: &check.Policy{}, RootOfTrust: &check.RootOfTrust{}}
-
-	attestationPolicy, err := os.ReadFile(fileName)
-	if err != nil {
-		return errors.Wrap(errReadingAttestationPolicyFile, err)
-	}
-
-	if err = protojson.Unmarshal(attestationPolicy, &ac); err != nil {
-		return errors.Wrap(errUnmarshalJSON, err)
-	}
-
-	switch field {
-	case measurementField:
-		ac.Policy.Measurement = data
-	case hostDataField:
-		ac.Policy.HostData = data
-	default:
-		return errAttestationPolicyField
-	}
-
-	fileJson, err := protojson.Marshal(&ac)
-	if err != nil {
-		return errors.Wrap(errMarshalJSON, err)
-	}
-	if err = os.WriteFile(fileName, fileJson, filePermission); err != nil {
-		return errors.Wrap(errWriteFile, err)
-	}
-	return nil
-}
@@ -1,131 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"encoding/base64"
-	"os"
-	"testing"
-
-	"github.com/google/go-sev-guest/proto/check"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-func TestChangeAttestationConfiguration(t *testing.T) {
-	tmpfile, err := os.CreateTemp("", "attestation_policy.json")
-	require.NoError(t, err)
-	defer os.Remove(tmpfile.Name())
-
-	initialConfig := check.Config{Policy: &check.Policy{}, RootOfTrust: &check.RootOfTrust{}}
-
-	initialJSON, err := protojson.Marshal(&initialConfig)
-	require.NoError(t, err)
-	err = os.WriteFile(tmpfile.Name(), initialJSON, 0o644)
-	require.NoError(t, err)
-
-	tests := []struct {
-		name           string
-		base64Data     string
-		expectedLength int
-		field          fieldType
-		expectError    bool
-		errorType      error
-	}{
-		{
-			name:           "Valid Measurement",
-			base64Data:     base64.StdEncoding.EncodeToString(make([]byte, measurementLength)),
-			expectedLength: measurementLength,
-			field:          measurementField,
-			expectError:    false,
-		},
-		{
-			name:           "Valid Host Data",
-			base64Data:     base64.StdEncoding.EncodeToString(make([]byte, hostDataLength)),
-			expectedLength: hostDataLength,
-			field:          hostDataField,
-			expectError:    false,
-		},
-		{
-			name:           "Invalid Base64",
-			base64Data:     "Invalid Base64",
-			expectedLength: measurementLength,
-			field:          measurementField,
-			expectError:    true,
-			errorType:      errDecode,
-		},
-		{
-			name:           "Invalid Data Length",
-			base64Data:     base64.StdEncoding.EncodeToString(make([]byte, measurementLength-1)),
-			expectedLength: measurementLength,
-			field:          measurementField,
-			expectError:    true,
-			errorType:      errDataLength,
-		},
-		{
-			name:           "Invalid Field Type",
-			base64Data:     base64.StdEncoding.EncodeToString(make([]byte, measurementLength)),
-			expectedLength: measurementLength,
-			field:          fieldType(999),
-			expectError:    true,
-			errorType:      errAttestationPolicyField,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := changeAttestationConfiguration(tmpfile.Name(), tt.base64Data, tt.expectedLength, tt.field)
-
-			if tt.expectError {
-				assert.Error(t, err)
-				assert.ErrorIs(t, err, tt.errorType)
-			} else {
-				assert.NoError(t, err)
-
-				content, err := os.ReadFile(tmpfile.Name())
-				require.NoError(t, err)
-
-				config := check.Config{Policy: &check.Policy{}, RootOfTrust: &check.RootOfTrust{}}
-				err = protojson.Unmarshal(content, &config)
-				require.NoError(t, err)
-
-				decodedData, _ := base64.StdEncoding.DecodeString(tt.base64Data)
-				if tt.field == measurementField {
-					assert.Equal(t, decodedData, config.Policy.Measurement)
-				} else if tt.field == hostDataField {
-					assert.Equal(t, decodedData, config.Policy.HostData)
-				}
-			}
-		})
-	}
-}
-
-func TestNewAttestationPolicyCmd(t *testing.T) {
-	cli := &CLI{}
-	cmd := cli.NewAttestationPolicyCmd()
-
-	assert.Equal(t, "policy [command]", cmd.Use)
-	assert.Equal(t, "Change attestation policy", cmd.Short)
-	assert.NotNil(t, cmd.Run)
-}
-
-func TestNewAddMeasurementCmd(t *testing.T) {
-	cli := &CLI{}
-	cmd := cli.NewAddMeasurementCmd()
-
-	assert.Equal(t, "measurement", cmd.Use)
-	assert.Equal(t, "Add measurement to the attestation policy file. The value should be in base64. The second parameter is attestation_policy.json file", cmd.Short)
-	assert.Equal(t, "measurement <measurement> <attestation_policy.json>", cmd.Example)
-	assert.NotNil(t, cmd.Run)
-}
-
-func TestNewAddHostDataCmd(t *testing.T) {
-	cli := &CLI{}
-	cmd := cli.NewAddHostDataCmd()
-
-	assert.Equal(t, "hostdata", cmd.Use)
-	assert.Equal(t, "Add host data to the attestation policy file. The value should be in base64. The second parameter is attestation_policy.json file", cmd.Short)
-	assert.Equal(t, "hostdata <host-data> <attestation_policy.json>", cmd.Example)
-	assert.NotNil(t, cmd.Run)
-}
@@ -1,450 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"bytes"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"os"
-	"testing"
-
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/google/go-sev-guest/abi"
-	"github.com/google/go-sev-guest/proto/check"
-	"github.com/google/go-sev-guest/proto/sevsnp"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/pkg/sdk/mocks"
-)
-
-func TestNewAttestationCmd(t *testing.T) {
-	mockSDK := new(mocks.SDK)
-	cli := &CLI{agentSDK: mockSDK}
-	cmd := cli.NewAttestationCmd()
-
-	assert.Equal(t, "attestation [command]", cmd.Use)
-	assert.Equal(t, "Get and validate attestations", cmd.Short)
-
-	var buf bytes.Buffer
-	cmd.SetOut(&buf)
-
-	cmd.SetOutput(&buf)
-
-	reportData := bytes.Repeat([]byte{0x01}, agent.ReportDataSize)
-	mockSDK.On("Attestation", mock.Anything, [agent.ReportDataSize]byte(reportData), mock.Anything).Return(nil)
-
-	cmd.SetArgs([]string{hex.EncodeToString(reportData)})
-	err := cmd.Execute()
-	assert.NoError(t, err)
-	assert.Contains(t, buf.String(), "Get and validate attestations")
-}
-
-func TestNewGetAttestationCmd(t *testing.T) {
-	validattestation, err := os.ReadFile("../attestation.bin")
-	require.NoError(t, err)
-	testCases := []struct {
-		name         string
-		args         []string
-		mockResponse []byte
-		mockError    error
-		expectedErr  string
-		expectedOut  string
-	}{
-		{
-			name:         "successful attestation retrieval",
-			args:         []string{hex.EncodeToString(bytes.Repeat([]byte{0x01}, agent.ReportDataSize))},
-			mockResponse: []byte("mock attestation"),
-			mockError:    nil,
-			expectedOut:  "Attestation result retrieved and saved successfully!",
-		},
-		{
-			name:         "invalid report data (decoding error)",
-			args:         []string{"invalid"},
-			mockResponse: nil,
-			mockError:    errors.New("error"),
-			expectedErr:  "Error decoding report data",
-		},
-		{
-			name:         "invalid report data size",
-			args:         []string{hex.EncodeToString(bytes.Repeat([]byte{0x01}, 32))},
-			mockResponse: nil,
-			mockError:    errors.New("error"),
-			expectedErr:  "report data must be a hex encoded string of length 64 bytes",
-		},
-		{
-			name:         "invalid report data hex",
-			args:         []string{"invalid"},
-			mockResponse: nil,
-			mockError:    errors.New("error"),
-			expectedErr:  "Error decoding report data",
-		},
-		{
-			name:         "failed to get attestation",
-			args:         []string{hex.EncodeToString(bytes.Repeat([]byte{0x01}, agent.ReportDataSize))},
-			mockResponse: nil,
-			mockError:    errors.New("error"),
-			expectedErr:  "Failed to get attestation due to error",
-		},
-		{
-			name:         "JSON report error",
-			args:         []string{hex.EncodeToString(bytes.Repeat([]byte{0x01}, agent.ReportDataSize)), "--json"},
-			mockResponse: []byte("mock attestation"),
-			mockError:    nil,
-			expectedErr:  "Error converting attestation to json",
-		},
-		{
-			name:         "successful JSON report",
-			args:         []string{hex.EncodeToString(bytes.Repeat([]byte{0x01}, agent.ReportDataSize)), "--json"},
-			mockResponse: validattestation,
-			mockError:    nil,
-			expectedOut:  "Attestation result retrieved and saved successfully!",
-		},
-		{
-			name:         "connection error",
-			args:         []string{hex.EncodeToString(bytes.Repeat([]byte{0x01}, agent.ReportDataSize))},
-			mockResponse: nil,
-			mockError:    errors.New("failed to connect to agent"),
-			expectedErr:  "Failed to connect to agent",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Cleanup(func() {
-				os.Remove(attestationFilePath)
-				os.Remove(attestationJson)
-			})
-			mockSDK := new(mocks.SDK)
-			cli := &CLI{agentSDK: mockSDK}
-			if tc.name == "connection error" {
-				cli.connectErr = errors.New("failed to connect to agent")
-			}
-			cmd := cli.NewGetAttestationCmd()
-			var buf bytes.Buffer
-			cmd.SetOutput(&buf)
-
-			mockSDK.On("Attestation", mock.Anything, [agent.ReportDataSize]byte(bytes.Repeat([]byte{0x01}, agent.ReportDataSize)), mock.Anything).Return(tc.mockError).Run(func(args mock.Arguments) {
-				_, err := args.Get(2).(*os.File).Write(tc.mockResponse)
-				require.NoError(t, err)
-			})
-
-			cmd.SetArgs(tc.args)
-			err := cmd.Execute()
-
-			if tc.expectedErr != "" {
-				assert.Contains(t, buf.String(), tc.expectedErr)
-			} else {
-				assert.NoError(t, err)
-				assert.Contains(t, buf.String(), tc.expectedOut)
-			}
-		})
-	}
-}
-
-func TestNewValidateAttestationValidationCmd(t *testing.T) {
-	cli := &CLI{}
-	cmd := cli.NewValidateAttestationValidationCmd()
-
-	assert.Equal(t, "validate", cmd.Use)
-	assert.Equal(t, "Validate and verify attestation information. The report is provided as a file path.", cmd.Short)
-
-	assert.Equal(t, fmt.Sprint(defaultMinimumTcb), cmd.Flag("minimum_tcb").Value.String())
-	assert.Equal(t, fmt.Sprint(defaultMinimumLaunchTcb), cmd.Flag("minimum_lauch_tcb").Value.String())
-	assert.Equal(t, fmt.Sprint(defaultGuestPolicy), cmd.Flag("guest_policy").Value.String())
-	assert.Equal(t, fmt.Sprint(defaultMinimumGuestSvn), cmd.Flag("minimum_guest_svn").Value.String())
-	assert.Equal(t, fmt.Sprint(defaultMinimumBuild), cmd.Flag("minimum_build").Value.String())
-	assert.Equal(t, defaultCheckCrl, cmd.Flag("check_crl").Value.String() == "true")
-	assert.Equal(t, fmt.Sprint(defaultTimeout), cmd.Flag("timeout").Value.String())
-	assert.Equal(t, fmt.Sprint(defaultMaxRetryDelay), cmd.Flag("max_retry_delay").Value.String())
-}
-
-func TestParseConfig(t *testing.T) {
-	cfgString = ""
-	err := parseConfig()
-	assert.NoError(t, err)
-	assert.NotNil(t, cfg.RootOfTrust)
-	assert.NotNil(t, cfg.Policy)
-
-	cfgString = `{"rootOfTrust":{"product":"test_product"},"policy":{"minimumGuestSvn":1}}`
-	err = parseConfig()
-	assert.NoError(t, err)
-	assert.Equal(t, "test_product", cfg.RootOfTrust.Product)
-	assert.Equal(t, uint32(1), cfg.Policy.MinimumGuestSvn)
-
-	cfgString = `{"invalid_json"`
-	err = parseConfig()
-	assert.Error(t, err)
-}
-
-func TestParseHashes(t *testing.T) {
-	trustedAuthorHashes = []string{"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"}
-	trustedIdKeyHashes = []string{"fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210"}
-
-	cfg = check.Config{}
-	if cfg.Policy == nil {
-		cfg.Policy = &check.Policy{}
-	}
-
-	err := parseHashes()
-	assert.NoError(t, err)
-	assert.Len(t, cfg.Policy.TrustedAuthorKeyHashes, 1)
-	assert.Len(t, cfg.Policy.TrustedIdKeyHashes, 1)
-
-	trustedAuthorHashes = []string{"invalid_hash"}
-	err = parseHashes()
-	assert.Error(t, err)
-}
-
-func TestParseFiles(t *testing.T) {
-	attestationFile = "test_attestation.bin"
-	authorKeyFile := "test_author_key.pem"
-	idKeyFile := "test_id_key.pem"
-
-	err := os.WriteFile(attestationFile, []byte("test attestation"), 0o644)
-	assert.NoError(t, err)
-	err = os.WriteFile(authorKeyFile, []byte("test author key"), 0o644)
-	assert.NoError(t, err)
-	err = os.WriteFile(idKeyFile, []byte("test id key"), 0o644)
-	assert.NoError(t, err)
-
-	trustedAuthorKeys = []string{authorKeyFile}
-	trustedIdKeys = []string{idKeyFile}
-
-	err = parseFiles()
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("test attestation"), attestation)
-	assert.Len(t, cfg.Policy.TrustedAuthorKeys, 1)
-	assert.Len(t, cfg.Policy.TrustedIdKeys, 1)
-
-	os.Remove(attestationFile)
-	os.Remove(authorKeyFile)
-	os.Remove(idKeyFile)
-
-	attestationFile = "non_existent_file.bin"
-	err = parseFiles()
-	assert.Error(t, err)
-}
-
-func TestParseUints(t *testing.T) {
-	stepping = "10"
-	platformInfo = "0xFF"
-
-	cfg = check.Config{}
-	if cfg.Policy == nil {
-		cfg.Policy = &check.Policy{
-			Product: &sevsnp.SevProduct{},
-		}
-	}
-	err := parseUints()
-	assert.NoError(t, err)
-	assert.Equal(t, uint32(10), cfg.Policy.Product.MachineStepping.Value)
-	assert.Equal(t, uint64(255), cfg.Policy.PlatformInfo.Value)
-
-	stepping = "invalid"
-	err = parseUints()
-	assert.Error(t, err)
-
-	stepping = "10"
-	platformInfo = "invalid"
-	err = parseUints()
-	assert.Error(t, err)
-}
-
-func TestValidateInput(t *testing.T) {
-	cfg = check.Config{}
-	if cfg.Policy == nil {
-		cfg.Policy = &check.Policy{}
-	}
-	if cfg.RootOfTrust == nil {
-		cfg.RootOfTrust = &check.RootOfTrust{}
-	}
-	cfg.Policy.ReportData = make([]byte, 64)
-	cfg.Policy.HostData = make([]byte, 32)
-	cfg.Policy.FamilyId = make([]byte, 16)
-	cfg.Policy.ImageId = make([]byte, 16)
-	cfg.Policy.ReportId = make([]byte, 32)
-	cfg.Policy.ReportIdMa = make([]byte, 32)
-	cfg.Policy.Measurement = make([]byte, 48)
-	cfg.Policy.ChipId = make([]byte, 64)
-
-	err := validateInput()
-	assert.NoError(t, err)
-
-	cfg.Policy.ReportData = make([]byte, 32)
-	err = validateInput()
-	assert.Error(t, err)
-}
-
-func TestGetBase(t *testing.T) {
-	assert.Equal(t, 16, getBase("0xFF"))
-	assert.Equal(t, 8, getBase("0o77"))
-	assert.Equal(t, 2, getBase("0b1010"))
-	assert.Equal(t, 10, getBase("123"))
-}
-
-func TestAttestationToJSON(t *testing.T) {
-	validReport, err := os.ReadFile("../attestation.bin")
-	require.NoError(t, err)
-	tests := []struct {
-		name  string
-		input []byte
-		err   error
-	}{
-		{
-			name:  "Valid report",
-			input: validReport,
-			err:   nil,
-		},
-		{
-			name:  "Invalid report size",
-			input: make([]byte, abi.ReportSize-1),
-			err:   errReportSize,
-		},
-		{
-			name:  "Nil input",
-			input: nil,
-			err:   errReportSize,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := attesationToJSON(tt.input)
-			assert.True(t, errors.Contains(err, tt.err))
-			if tt.err != nil {
-				assert.Nil(t, got)
-				return
-			}
-
-			require.NotNil(t, got)
-
-			var js map[string]interface{}
-			err = json.Unmarshal(got, &js)
-			assert.NoError(t, err)
-		})
-	}
-}
-
-func TestAttestationFromJSON(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    []byte
-		err      error
-		validate func(t *testing.T, output []byte)
-	}{
-		{
-			name: "Valid JSON",
-			input: func() []byte {
-				att := &sevsnp.Attestation{
-					Report: &sevsnp.Report{
-						CurrentTcb:      1,
-						FamilyId:        make([]byte, 16),
-						ImageId:         make([]byte, 16),
-						ReportData:      make([]byte, 64),
-						Measurement:     make([]byte, 48),
-						HostData:        make([]byte, 32),
-						IdKeyDigest:     make([]byte, 48),
-						AuthorKeyDigest: make([]byte, 48),
-						ReportId:        make([]byte, 32),
-						ReportIdMa:      make([]byte, 32),
-						ChipId:          make([]byte, 64),
-						Signature:       make([]byte, 512),
-					},
-				}
-				data, err := json.Marshal(att)
-				require.NoError(t, err)
-				return data
-			}(),
-			err: nil,
-			validate: func(t *testing.T, output []byte) {
-				assert.NotEmpty(t, output)
-			},
-		},
-		{
-			name:  "Invalid JSON",
-			input: []byte(`{"invalid": json`),
-			err:   errors.New("invalid character 'j' looking for beginning of value"),
-			validate: func(t *testing.T, output []byte) {
-				assert.Nil(t, output)
-			},
-		},
-		{
-			name:  "Empty input",
-			input: []byte{},
-			err:   errors.New("unexpected end of JSON input"),
-			validate: func(t *testing.T, output []byte) {
-				assert.Nil(t, output)
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := attesationFromJSON(tt.input)
-			assert.True(t, errors.Contains(err, tt.err))
-			tt.validate(t, got)
-		})
-	}
-}
-
-func TestIsFileJSON(t *testing.T) {
-	tests := []struct {
-		name     string
-		filename string
-		want     bool
-	}{
-		{
-			name:     "Valid JSON extension",
-			filename: "test.json",
-			want:     true,
-		},
-		{
-			name:     "Valid JSON extension with path",
-			filename: "/path/to/test.json",
-			want:     true,
-		},
-		{
-			name:     "Invalid extension",
-			filename: "test.txt",
-			want:     false,
-		},
-		{
-			name:     "No extension",
-			filename: "test",
-			want:     false,
-		},
-		{
-			name:     "JSON in filename",
-			filename: "json.txt",
-			want:     false,
-		},
-		{
-			name:     "Empty string",
-			filename: "",
-			want:     false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := isFileJSON(tt.filename)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func TestRoundTrip(t *testing.T) {
-	originalReport, err := os.ReadFile("../attestation.bin")
-	require.NoError(t, err)
-	jsonData, err := attesationToJSON(originalReport)
-	require.NoError(t, err)
-	require.NotNil(t, jsonData)
-
-	roundTripReport, err := attesationFromJSON(jsonData)
-	require.NoError(t, err)
-	require.NotNil(t, roundTripReport)
-}
@@ -1,78 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"fmt"
-	"os"
-	"path"
-
-	"github.com/google/go-sev-guest/abi"
-	"github.com/google/go-sev-guest/kds"
-	"github.com/google/go-sev-guest/proto/check"
-	"github.com/google/go-sev-guest/verify/trust"
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
-)
-
-const (
-	caBundleName      = "ask_ark.pem"
-	filePermisionKeys = 0o766
-)
-
-func (cli *CLI) NewCABundleCmd(fileSavePath string) *cobra.Command {
-	return &cobra.Command{
-		Use:     "ca-bundle",
-		Short:   "Fetch AMD SEV-SNPs CA Bundle (ASK and ARK)",
-		Example: "ca-bundle <path_to_platform_info_json>",
-		Args:    cobra.ExactArgs(1),
-		Run: func(cmd *cobra.Command, args []string) {
-			attestationConfiguration := check.Config{Policy: &check.Policy{}, RootOfTrust: &check.RootOfTrust{}}
-			err := grpc.ReadAttestationPolicy(args[0], &attestationConfiguration)
-			if err != nil {
-				printError(cmd, "Error while reading manifest: %v ❌ ", err)
-				return
-			}
-
-			product := attestationConfiguration.RootOfTrust.ProductLine
-
-			getter := trust.DefaultHTTPSGetter()
-			caURL := kds.ProductCertChainURL(abi.VcekReportSigner, product)
-
-			bundle, err := getter.Get(caURL)
-			if err != nil {
-				message := fmt.Sprintf("Error fetching ARK and ASK from AMD KDS for product: %s", product)
-				message += ", error: %v ❌ "
-				printError(cmd, message, err)
-				return
-			}
-
-			err = os.MkdirAll(path.Join(fileSavePath, product), filePermisionKeys)
-			if err != nil {
-				message := fmt.Sprintf("Error while creating directory for product name %s", product)
-				message += ", error: %v ❌ "
-				printError(cmd, message, err)
-				return
-			}
-
-			bundlePath := path.Join(fileSavePath, product, caBundleName)
-			if err = saveToFile(bundlePath, bundle); err != nil {
-				printError(cmd, "Error while saving ARK-ASK to file: %v ❌ ", err)
-				return
-			}
-		},
-	}
-}
-
-func saveToFile(fileSavePath string, content []byte) error {
-	file, err := os.OpenFile(fileSavePath, os.O_CREATE|os.O_RDWR|os.O_TRUNC, filePermisionKeys)
-	if err != nil {
-		return err
-	}
-
-	if _, err := file.Write(content); err != nil {
-		return err
-	}
-
-	return nil
-}
@@ -1,59 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"bytes"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewCABundleCmd(t *testing.T) {
-	cli := &CLI{}
-	tempDir, err := os.MkdirTemp("", "ca-bundle-test")
-	assert.NoError(t, err)
-	defer os.RemoveAll(tempDir)
-
-	manifestContent := []byte(`{"root_of_trust": {"product_line": "Milan"}}`)
-	manifestPath := path.Join(tempDir, "manifest.json")
-	err = os.WriteFile(manifestPath, manifestContent, 0o644)
-	assert.NoError(t, err)
-
-	cmd := cli.NewCABundleCmd(tempDir)
-	cmd.SetArgs([]string{manifestPath})
-	output := &bytes.Buffer{}
-	cmd.SetOutput(output)
-	err = cmd.Execute()
-
-	assert.NoError(t, err)
-
-	expectedFilePath := path.Join(tempDir, "Milan", caBundleName)
-	_, err = os.Stat(expectedFilePath)
-	assert.NoError(t, err)
-
-	content, err := os.ReadFile(expectedFilePath)
-	assert.NoError(t, err)
-	assert.NotNil(t, content)
-}
-
-func TestSaveToFile(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "save-to-file-test")
-	assert.NoError(t, err)
-	defer os.RemoveAll(tempDir)
-
-	filePath := path.Join(tempDir, "test-file.txt")
-	content := []byte("test content")
-
-	err = saveToFile(filePath, content)
-	assert.NoError(t, err)
-
-	savedContent, err := os.ReadFile(filePath)
-	assert.NoError(t, err)
-	assert.Equal(t, content, savedContent)
-
-	_, err = os.Stat(filePath)
-	assert.NoError(t, err)
-}
@@ -1,95 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
-	"os"
-
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/internal"
-	"golang.org/x/crypto/sha3"
-)
-
-var (
-	ismanifest bool
-	toBase64   bool
-)
-
-func (cli *CLI) NewFileHashCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "checksum",
-		Short:   "Compute the sha3-256 hash of a file",
-		Example: "checksum <file>",
-		Args:    cobra.ExactArgs(1),
-		Run: func(cmd *cobra.Command, args []string) {
-			path := args[0]
-
-			if ismanifest {
-				hash, err := manifestChecksum(path)
-				if err != nil {
-					printError(cmd, "Error computing hash: %v ❌ ", err)
-					return
-				}
-
-				cmd.Println("Hash of manifest file:", hashOut(hash))
-				return
-			}
-
-			hash, err := internal.ChecksumHex(path)
-			if err != nil {
-				printError(cmd, "Error computing hash: %v ❌ ", err)
-				return
-			}
-
-			cmd.Println("Hash of file:", hashOut(hash))
-		},
-	}
-
-	cmd.Flags().BoolVarP(&ismanifest, "manifest", "m", false, "Compute the hash of the manifest file")
-	cmd.Flags().BoolVarP(&toBase64, "base64", "b", false, "Output the hash in base64")
-
-	return cmd
-}
-
-func manifestChecksum(path string) (string, error) {
-	file, err := os.ReadFile(path)
-	if err != nil {
-		return "", err
-	}
-
-	var cmp agent.Computation
-
-	if err := json.Unmarshal(file, &cmp); err != nil {
-		return "", err
-	}
-
-	jsonBytes, err := json.Marshal(cmp)
-	if err != nil {
-		return "", err
-	}
-
-	sum := sha3.Sum256(jsonBytes)
-
-	return hex.EncodeToString(sum[:]), nil
-}
-
-func hashOut(hashHex string) string {
-	if toBase64 {
-		return hexToBase64(hashHex)
-	}
-
-	return hashHex
-}
-
-func hexToBase64(hexStr string) string {
-	decoded, err := hex.DecodeString(hexStr)
-	if err != nil {
-		return ""
-	}
-
-	return base64.StdEncoding.EncodeToString(decoded)
-}
@@ -1,230 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewFileHashCmd(t *testing.T) {
-	cli := &CLI{}
-	cmd := cli.NewFileHashCmd()
-
-	if cmd.Use != "checksum" {
-		t.Errorf("Expected Use to be 'checksum', got %s", cmd.Use)
-	}
-
-	if cmd.Short != "Compute the sha3-256 hash of a file" {
-		t.Errorf("Expected Short to be 'Compute the sha3-256 hash of a file', got %s", cmd.Short)
-	}
-
-	if cmd.Example != "checksum <file>" {
-		t.Errorf("Expected Example to be 'checksum <file>', got %s", cmd.Example)
-	}
-}
-
-func TestNewFileHashCmdRun(t *testing.T) {
-	testCases := []struct {
-		name        string
-		isManifest  bool
-		toBase64    bool
-		expectedOut string
-		expectedErr string
-	}{
-		{
-			name:        "Valid file",
-			isManifest:  false,
-			toBase64:    false,
-			expectedOut: "Hash of file:",
-			expectedErr: "",
-		},
-		{
-			name:        "Valid manifest file",
-			isManifest:  true,
-			toBase64:    false,
-			expectedOut: "Hash of manifest file:",
-			expectedErr: "",
-		},
-		{
-			name:        "Valid file with base64 output",
-			isManifest:  false,
-			toBase64:    true,
-			expectedOut: "Hash of file:",
-			expectedErr: "",
-		},
-		{
-			name:        "Non-existent file",
-			isManifest:  false,
-			toBase64:    false,
-			expectedOut: "Error computing hash:",
-			expectedErr: "",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			cli := &CLI{}
-			cmd := cli.NewFileHashCmd()
-
-			var output bytes.Buffer
-			cmd.SetOut(&output)
-			cmd.SetErr(&output)
-
-			err := cmd.Flags().Set("manifest", fmt.Sprint(tc.isManifest))
-			assert.Nil(t, err)
-			err = cmd.Flags().Set("base64", fmt.Sprint(tc.toBase64))
-			assert.Nil(t, err)
-
-			if tc.name == "Non-existent file" {
-				cmd.SetArgs([]string{"non_existent_file.txt"})
-			} else {
-				content := []byte("{}")
-				tmpfile, err := os.CreateTemp("", "example")
-				if err != nil {
-					t.Fatal(err)
-				}
-				defer os.Remove(tmpfile.Name())
-
-				if _, err := tmpfile.Write(content); err != nil {
-					t.Fatal(err)
-				}
-				if err := tmpfile.Close(); err != nil {
-					t.Fatal(err)
-				}
-
-				cmd.SetArgs([]string{tmpfile.Name()})
-			}
-
-			err = cmd.Execute()
-			if err != nil {
-				t.Fatalf("Error executing command: %v", err)
-			}
-
-			out := output.String()
-			if !strings.Contains(out, tc.expectedOut) {
-				t.Errorf("Expected output to contain '%s', got '%s'", tc.expectedOut, out)
-			}
-
-			if tc.expectedErr != "" && !strings.Contains(out, tc.expectedErr) {
-				t.Errorf("Expected output to contain '%s', got '%s'", tc.expectedErr, out)
-			}
-		})
-	}
-}
-
-func TestManifestChecksum(t *testing.T) {
-	testCases := []struct {
-		name        string
-		jsonContent string
-		expectedSum string
-	}{
-		{
-			name: "Valid manifest file",
-			jsonContent: `{
-				"id": "1234",
-				"name": "Example Computation",
-				"description": "This is an example computation"
-			}`,
-			expectedSum: "868825367c32c4b6d621d5d95e2890f233d8554df2348ab743aac2663a936f08",
-		},
-		{
-			name:        "Invalid JSON",
-			jsonContent: `{`,
-			expectedSum: "",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			f, err := os.CreateTemp("", "test")
-			assert.Nil(t, err)
-
-			t.Cleanup(func() {
-				os.Remove(f.Name())
-			})
-
-			_, err = f.WriteString(tc.jsonContent)
-			assert.NoError(t, err)
-
-			err = f.Close()
-			assert.Nil(t, err)
-
-			hash, err := manifestChecksum(f.Name())
-			if tc.expectedSum == "" && err == nil {
-				t.Errorf("Expected error, got nil")
-			}
-			if tc.expectedSum != "" && err != nil {
-				t.Errorf("Unexpected error: %v", err)
-			}
-			if hash != tc.expectedSum {
-				t.Errorf("Expected hash %s, got %s", tc.expectedSum, hash)
-			}
-		})
-	}
-}
-
-func TestHexToBase64(t *testing.T) {
-	testCases := []struct {
-		name        string
-		hexInput    string
-		expectedOut string
-	}{
-		{
-			name:        "Valid hex input",
-			hexInput:    "48656c6c6f",
-			expectedOut: "SGVsbG8=",
-		},
-		{
-			name:        "Invalid hex input",
-			hexInput:    "invalid-hex",
-			expectedOut: "",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			out := hexToBase64(tc.hexInput)
-			if out != tc.expectedOut {
-				t.Errorf("Expected %s, got %s", tc.expectedOut, out)
-			}
-		})
-	}
-}
-
-func TestHashOut(t *testing.T) {
-	testCases := []struct {
-		name        string
-		hashHex     string
-		toBase64    bool
-		expectedOut string
-	}{
-		{
-			name:        "Hex output",
-			hashHex:     "48656c6c6f",
-			toBase64:    false,
-			expectedOut: "48656c6c6f",
-		},
-		{
-			name:        "Base64 output",
-			hashHex:     "48656c6c6f",
-			toBase64:    true,
-			expectedOut: "SGVsbG8=",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			toBase64 = tc.toBase64
-			out := hashOut(tc.hashHex)
-			if out != tc.expectedOut {
-				t.Errorf("Expected %s, got %s", tc.expectedOut, out)
-			}
-		})
-	}
-}
@@ -3,116 +3,40 @@
 package cli

 import (
-	"context"
-	"crypto/x509"
-	"encoding/pem"
+	"log"
 	"os"
-	"path"

-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/internal"
-	"google.golang.org/grpc/metadata"
 )

-var decompressDataset bool
-
 func (cli *CLI) NewDatasetsCmd() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:     "data",
-		Short:   "Upload a dataset",
-		Example: "data <dataset_path> <private_key_file_path>",
-		Args:    cobra.ExactArgs(2),
+		Short:   "Upload a dataset CSV file",
+		Example: "data <dataset.csv> <id> <provider>",
+		Args:    cobra.ExactArgs(3),
 		Run: func(cmd *cobra.Command, args []string) {
-			if cli.connectErr != nil {
-				printError(cmd, "Failed to connect to agent: %v ❌ ", cli.connectErr)
-				return
-			}
+			datasetFile := args[0]

-			datasetPath := args[0]
+			log.Println("Uploading dataset CSV:", datasetFile)

-			cmd.Println("Uploading dataset:", datasetPath)
-
-			f, err := os.Stat(datasetPath)
+			dataset, err := os.ReadFile(datasetFile)
 			if err != nil {
-				printError(cmd, "Error reading dataset file: %v ❌ ", err)
-				return
+				log.Fatalf("Error reading dataset file: %v", err)
 			}

-			var dataset *os.File
-
-			if f.IsDir() {
-				dataset, err = internal.ZipDirectoryToTempFile(datasetPath)
-				if err != nil {
-					printError(cmd, "Error zipping dataset directory: %v ❌ ", err)
-					return
-				}
-				defer dataset.Close()
-				defer os.Remove(dataset.Name())
-			} else {
-				dataset, err = os.Open(datasetPath)
-				if err != nil {
-					printError(cmd, "Error reading dataset file: %v ❌ ", err)
-					return
-				}
-				defer dataset.Close()
+			dataReq := agent.Dataset{
+				Dataset:  dataset,
+				ID:       args[1],
+				Provider: args[2],
 			}

-			privKeyFile, err := os.ReadFile(args[1])
-			if err != nil {
-				printError(cmd, "Error reading private key file: %v ❌ ", err)
-				return
+			if err := cli.agentSDK.Data(cmd.Context(), dataReq); err != nil {
+				log.Fatalf("Error uploading dataset: %v", err)
 			}

-			pemBlock, _ := pem.Decode(privKeyFile)
-
-			privKey, err := decodeKey(pemBlock)
-			if err != nil {
-				printError(cmd, "Error decoding private key: %v ❌ ", err)
-				return
-			}
-
-			ctx := metadata.NewOutgoingContext(cmd.Context(), metadata.New(make(map[string]string)))
-			if err := cli.agentSDK.Data(addDatasetMetadata(ctx), dataset, path.Base(datasetPath), privKey); err != nil {
-				printError(cmd, "Failed to upload dataset due to error: %v ❌ ", err)
-				return
-			}
-
-			cmd.Println(color.New(color.FgGreen).Sprint("Successfully uploaded dataset! ✔ "))
+			log.Println("Successfully uploaded dataset")
 		},
 	}
-
-	cmd.Flags().BoolVarP(&decompressDataset, "decompress", "d", false, "Decompress the dataset on agent")
-	return cmd
-}
-
-func decodeKey(b *pem.Block) (interface{}, error) {
-	if b == nil {
-		return nil, errors.New("error decoding key")
-	}
-	switch b.Type {
-	case rsaKeyType:
-		privKey, err := x509.ParsePKCS8PrivateKey(b.Bytes)
-		if err != nil {
-			privKey, err = x509.ParsePKCS1PrivateKey(b.Bytes)
-			if err != nil {
-				return nil, err
-			}
-		}
-		return privKey, nil
-	case ecdsaKeyType:
-		privKey, err := x509.ParseECPrivateKey(b.Bytes)
-		if err != nil {
-			return nil, err
-		}
-		return privKey, nil
-	default:
-		return nil, errors.New("error decoding key")
-	}
-}
-
-func addDatasetMetadata(ctx context.Context) context.Context {
-	return agent.DecompressToContext(ctx, decompressDataset)
 }
@@ -1,158 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/pkg/sdk/mocks"
-)
-
-func createTempDatasetFile(content string) (string, error) {
-	tmpFile, err := os.CreateTemp("", "dataset-*.txt")
-	if err != nil {
-		return "", err
-	}
-	defer tmpFile.Close()
-
-	_, err = tmpFile.WriteString(content)
-	if err != nil {
-		return "", err
-	}
-	return tmpFile.Name(), nil
-}
-
-func TestDatasetsCmd(t *testing.T) {
-	tests := []struct {
-		name           string
-		setupMock      func(*mocks.SDK)
-		setupFiles     func() (string, error)
-		connectErr     error
-		expectedOutput string
-		cleanup        func(string, string)
-	}{
-		{
-			name: "successful upload",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Data", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() (string, error) {
-				datasetFile, err := createTempDatasetFile("test dataset content")
-				if err != nil {
-					return "", err
-				}
-				err = generateRSAPrivateKeyFile(privateKeyFile)
-				return datasetFile, err
-			},
-			expectedOutput: "Successfully uploaded dataset",
-			cleanup: func(datasetFile, privateKeyFile string) {
-				os.Remove(datasetFile)
-				os.Remove(privateKeyFile)
-			},
-		},
-		{
-			name: "missing dataset file",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Data", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() (string, error) {
-				return "", nil
-			},
-			expectedOutput: "Error reading dataset file",
-		},
-		{
-			name: "missing private key file",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Data", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() (string, error) {
-				return createTempDatasetFile("test dataset content")
-			},
-			expectedOutput: "Error reading private key file",
-			cleanup: func(datasetFile, _ string) {
-				os.Remove(datasetFile)
-			},
-		},
-		{
-			name: "upload failure",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Data", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("failed to upload algorithm due to error"))
-			},
-			setupFiles: func() (string, error) {
-				datasetFile, err := createTempDatasetFile("test dataset content")
-				if err != nil {
-					return "", err
-				}
-				err = generateRSAPrivateKeyFile(privateKeyFile)
-				return datasetFile, err
-			},
-			expectedOutput: "Failed to upload dataset due to error",
-			cleanup: func(datasetFile, privateKeyFile string) {
-				os.Remove(datasetFile)
-				os.Remove(privateKeyFile)
-			},
-		},
-		{
-			name: "invalid private key",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Data", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-			},
-			setupFiles: func() (string, error) {
-				datasetFile, err := createTempDatasetFile("test dataset content")
-				if err != nil {
-					return "", err
-				}
-				err = os.WriteFile(privateKeyFile, []byte("invalid private key"), 0o644)
-				return datasetFile, err
-			},
-			expectedOutput: "Error decoding private key",
-			cleanup: func(datasetFile, privateKeyFile string) {
-				os.Remove(datasetFile)
-				os.Remove(privateKeyFile)
-			},
-		},
-		{
-			name: "connection error",
-			setupMock: func(m *mocks.SDK) {
-			},
-			setupFiles:     func() (string, error) { return "", nil },
-			connectErr:     errors.New("failed to connect to agent"),
-			expectedOutput: "Failed to connect to agent",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockSDK := new(mocks.SDK)
-			if tt.setupMock != nil {
-				tt.setupMock(mockSDK)
-			}
-
-			testCLI := CLI{
-				agentSDK:   mockSDK,
-				connectErr: tt.connectErr,
-			}
-
-			datasetFile, err := tt.setupFiles()
-			require.NoError(t, err)
-
-			cmd := testCLI.NewDatasetsCmd()
-			buf := new(bytes.Buffer)
-			cmd.SetOut(buf)
-			cmd.SetArgs([]string{datasetFile, privateKeyFile})
-			err = cmd.Execute()
-			require.NoError(t, err)
-
-			require.Contains(t, buf.String(), tt.expectedOutput)
-
-			if tt.cleanup != nil {
-				tt.cleanup(datasetFile, privateKeyFile)
-			}
-		})
-	}
-}
@@ -1,49 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"github.com/absmach/magistrala/pkg/errors"
-	"github.com/fatih/color"
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/agent/auth"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc/agent"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-var (
-	errAgentUnavailable                   = errors.New("agent is unavailable on the current address")
-	errDigitalSignatureVerificationFailed = errors.New("digital signature verification failed, check the provided public key")
-)
-
-func decodeErros(err error) error {
-	statusErr, ok := status.FromError(err)
-	if ok {
-		switch statusErr.Code() {
-		case codes.PermissionDenied:
-			return errDigitalSignatureVerificationFailed
-		case codes.Unavailable:
-			return errAgentUnavailable
-		case codes.Unknown:
-			return err
-		}
-	}
-	switch {
-	case errors.Contains(err, auth.ErrSignatureVerificationFailed):
-		return auth.ErrSignatureVerificationFailed
-
-	case errors.Contains(err, agent.ErrAgentServiceUnavailable):
-		return agent.ErrAgentServiceUnavailable
-	default:
-		return err
-	}
-}
-
-func printError(cmd *cobra.Command, message string, err error) {
-	if !Verbose {
-		err = decodeErros(err)
-	}
-	msg := color.New(color.FgRed).Sprintf(message, err)
-	cmd.Println(msg)
-}
@@ -1,110 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"bytes"
-	"errors"
-	"testing"
-
-	mgerrors "github.com/absmach/magistrala/pkg/errors"
-	"github.com/fatih/color"
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/agent/auth"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc/agent"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-func TestDecodeErros(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    error
-		expected error
-	}{
-		{
-			name:     "Permission Denied",
-			input:    status.Error(codes.PermissionDenied, "permission denied"),
-			expected: errDigitalSignatureVerificationFailed,
-		},
-		{
-			name:     "Unavailable",
-			input:    status.Error(codes.Unavailable, "service unavailable"),
-			expected: errAgentUnavailable,
-		},
-		{
-			name:     "Unknown",
-			input:    status.Error(codes.Unknown, "unknown error"),
-			expected: status.Error(codes.Unknown, "unknown error"),
-		},
-		{
-			name:     "Signature Verification Failed",
-			input:    mgerrors.Wrap(auth.ErrSignatureVerificationFailed, errors.New("wrapped error")),
-			expected: auth.ErrSignatureVerificationFailed,
-		},
-		{
-			name:     "Other Error",
-			input:    errors.New("other error"),
-			expected: errors.New("other error"),
-		},
-		{
-			name:     "Agent Service Unavailable",
-			input:    mgerrors.Wrap(agent.ErrAgentServiceUnavailable, errors.New("wrapped error")),
-			expected: agent.ErrAgentServiceUnavailable,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := decodeErros(tt.input)
-			if result.Error() != tt.expected.Error() {
-				t.Errorf("decodeErros(%v) = %v, want %v", tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestPrintError(t *testing.T) {
-	// Save the original color.NoColor value and restore it after the test
-	origNoColor := color.NoColor
-	color.NoColor = true
-	defer func() { color.NoColor = origNoColor }()
-
-	tests := []struct {
-		name     string
-		message  string
-		err      error
-		verbose  bool
-		expected string
-	}{
-		{
-			name:     "Non-verbose mode",
-			message:  "Error: %s",
-			err:      status.Error(codes.PermissionDenied, "permission denied"),
-			verbose:  false,
-			expected: "Error: digital signature verification failed, check the provided public key\n",
-		},
-		{
-			name:     "Verbose mode",
-			message:  "Error: %s",
-			err:      status.Error(codes.PermissionDenied, "permission denied"),
-			verbose:  true,
-			expected: "Error: rpc error: code = PermissionDenied desc = permission denied\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			Verbose = tt.verbose
-			cmd := &cobra.Command{}
-			buf := new(bytes.Buffer)
-			cmd.SetOut(buf)
-
-			printError(cmd, tt.message, tt.err)
-
-			if got := buf.String(); got != tt.expected {
-				t.Errorf("printError() output = %q, want %q", got, tt.expected)
-			}
-		})
-	}
-}
@@ -1,140 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-const (
-	keyBitSize     = 4096
-	rsaKeyType     = "PRIVATE KEY"
-	ecdsaKeyType   = "EC PRIVATE KEY"
-	ed25519KeyType = "PRIVATE KEY"
-	publicKeyType  = "PUBLIC KEY"
-	publicKeyFile  = "public.pem"
-	privateKeyFile = "private.pem"
-	ECDSA          = "ecdsa"
-	ED25519        = "ed25519"
-)
-
-var KeyType string
-
-func (cli *CLI) NewKeysCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "keys",
-		Short: "Generate a new public/private key pair",
-		Long: "Generates a new public/private key pair using an algorithm of the users choice.\n" +
-			"Supported algorithms are RSA, ecdsa, and ed25519.",
-		Example: "./build/cocos-cli keys -k rsa",
-		Args:    cobra.ExactArgs(0),
-		Run: func(cmd *cobra.Command, args []string) {
-			switch KeyType {
-			case ECDSA:
-				privEcdsaKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-				if err != nil {
-					printError(cmd, "Error generating keys: %v ❌ ", err)
-					return
-				}
-
-				pubKeyBytes, err := x509.MarshalPKIXPublicKey(&privEcdsaKey.PublicKey)
-				if err != nil {
-					printError(cmd, "Error marshalling public key: %v ❌ ", err)
-					return
-				}
-
-				if err := generateAndWriteKeys(privEcdsaKey, pubKeyBytes, ecdsaKeyType); err != nil {
-					printError(cmd, "Error generating and writing keys: %v ❌ ", err)
-					return
-				}
-
-			case ED25519:
-				pubEd25519Key, privEd25519Key, err := ed25519.GenerateKey(rand.Reader)
-				if err != nil {
-					printError(cmd, "Error generating keys: %v ❌ ", err)
-					return
-				}
-				pubKey, err := x509.MarshalPKIXPublicKey(pubEd25519Key)
-				if err != nil {
-					printError(cmd, "Error marshalling public key: %v ❌ ", err)
-					return
-				}
-				if err := generateAndWriteKeys(privEd25519Key, pubKey, ed25519KeyType); err != nil {
-					printError(cmd, "Error generating and writing keys: %v ❌ ", err)
-					return
-				}
-
-			default:
-				privKey, err := rsa.GenerateKey(rand.Reader, keyBitSize)
-				if err != nil {
-					printError(cmd, "Error generating keys: %v ❌ ", err)
-					return
-				}
-
-				pubKeyBytes, err := x509.MarshalPKIXPublicKey(&privKey.PublicKey)
-				if err != nil {
-					printError(cmd, "Error marshalling public key: %v ❌ ", err)
-					return
-				}
-				if err := generateAndWriteKeys(privKey, pubKeyBytes, rsaKeyType); err != nil {
-					printError(cmd, "Error generating and writing keys: %v ❌ ", err)
-					return
-				}
-			}
-
-			cmd.Printf("Successfully generated public/private key pair of type: %s", KeyType)
-		},
-	}
-}
-
-func generateAndWriteKeys(privKey interface{}, pubKeyBytes []byte, keyType string) error {
-	privFile, err := os.Create(privateKeyFile)
-	if err != nil {
-		return err
-	}
-	defer privFile.Close()
-
-	var b []byte
-	switch privKey := privKey.(type) {
-	case *rsa.PrivateKey:
-		b = x509.MarshalPKCS1PrivateKey(privKey)
-	case *ecdsa.PrivateKey:
-		b, err = x509.MarshalECPrivateKey(privKey)
-	case ed25519.PrivateKey:
-		b, err = x509.MarshalPKCS8PrivateKey(privKey)
-	}
-	if err != nil {
-		return err
-	}
-
-	if err := pem.Encode(privFile, &pem.Block{
-		Type:  keyType,
-		Bytes: b,
-	}); err != nil {
-		return err
-	}
-
-	pubFile, err := os.Create(publicKeyFile)
-	if err != nil {
-		return err
-	}
-	defer pubFile.Close()
-
-	if err := pem.Encode(pubFile, &pem.Block{
-		Type:  publicKeyType,
-		Bytes: pubKeyBytes,
-	}); err != nil {
-		return err
-	}
-
-	return nil
-}
@@ -1,92 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package cli
-
-import (
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"os"
-	"testing"
-)
-
-func TestNewKeysCmd(t *testing.T) {
-	cli := &CLI{}
-	cmd := cli.NewKeysCmd()
-
-	if cmd.Use != "keys" {
-		t.Errorf("Expected Use to be 'keys', got %s", cmd.Use)
-	}
-
-	if cmd.Short != "Generate a new public/private key pair" {
-		t.Errorf("Unexpected Short description: %s", cmd.Short)
-	}
-}
-
-func TestGenerateAndWriteKeys(t *testing.T) {
-	tests := []struct {
-		name    string
-		keyType string
-	}{
-		{"RSA", "rsa"},
-		{"ECDSA", "ecdsa"},
-		{"ED25519", "ed25519"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			KeyType = tt.keyType
-			cmd := (&CLI{}).NewKeysCmd()
-			cmd.Run(cmd, []string{})
-
-			if _, err := os.Stat(privateKeyFile); os.IsNotExist(err) {
-				t.Errorf("Private key file was not created")
-			}
-			if _, err := os.Stat(publicKeyFile); os.IsNotExist(err) {
-				t.Errorf("Public key file was not created")
-			}
-
-			privKeyData, err := os.ReadFile(privateKeyFile)
-			if err != nil {
-				t.Fatalf("Failed to read private key file: %v", err)
-			}
-			privPem, _ := pem.Decode(privKeyData)
-			if privPem == nil {
-				t.Fatalf("Failed to decode private key PEM")
-			}
-
-			var privKey interface{}
-			switch tt.keyType {
-			case "rsa":
-				privKey, err = x509.ParsePKCS1PrivateKey(privPem.Bytes)
-			case "ecdsa":
-				privKey, err = x509.ParseECPrivateKey(privPem.Bytes)
-			case "ed25519":
-				privKey, err = x509.ParsePKCS8PrivateKey(privPem.Bytes)
-			}
-			if err != nil {
-				t.Fatalf("Failed to parse private key: %v", err)
-			}
-
-			switch tt.keyType {
-			case "rsa":
-				if _, ok := privKey.(*rsa.PrivateKey); !ok {
-					t.Errorf("Expected RSA private key, got %T", privKey)
-				}
-			case "ecdsa":
-				if _, ok := privKey.(*ecdsa.PrivateKey); !ok {
-					t.Errorf("Expected ECDSA private key, got %T", privKey)
-				}
-			case "ed25519":
-				if _, ok := privKey.(ed25519.PrivateKey); !ok {
-					t.Errorf("Expected ED25519 private key, got %T", privKey)
-				}
-			}
-
-			os.Remove(privateKeyFile)
-			os.Remove(publicKeyFile)
-		})
-	}
-}
@@ -3,65 +3,32 @@
 package cli

 import (
-	"encoding/pem"
+	"log"
 	"os"

-	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 )

-const (
-	resultFilePrefix = "results"
-	resultFileExt    = ".zip"
-	resultfilename   = "results.zip"
-)
+const resultFilePath = "result.bin"

 func (cli *CLI) NewResultsCmd() *cobra.Command {
 	return &cobra.Command{
-		Use:     "result",
-		Short:   "Retrieve computation result file",
-		Example: "result <private_key_file_path> <optional_file_name.zip>",
-		Args:    cobra.MinimumNArgs(1),
+		Use:   "result",
+		Short: "Retrieve computation result file",
+		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
-			if cli.connectErr != nil {
-				printError(cmd, "Failed to connect to agent: %v ❌ ", cli.connectErr)
-				return
-			}
+			log.Println("Retrieving computation result file")

-			cmd.Println("⏳ Retrieving computation result file")
-
-			privKeyFile, err := os.ReadFile(args[0])
+			result, err := cli.agentSDK.Result(cmd.Context(), args[0])
 			if err != nil {
-				printError(cmd, "Error reading private key file: %v ❌ ", err)
-				return
+				log.Fatalf("Error retrieving computation result: %v", err)
 			}

-			filename := resultfilename
-			if len(args) > 1 {
-				filename = args[1]
+			if err := os.WriteFile(resultFilePath, result, 0o644); err != nil {
+				log.Fatalf("Error saving computation result to %s: %v", resultFilePath, err)
 			}

-			pemBlock, _ := pem.Decode(privKeyFile)
-
-			privKey, err := decodeKey(pemBlock)
-			if err != nil {
-				printError(cmd, "Error decoding private key: %v ❌ ", err)
-				return
-			}
-
-			resultFile, err := os.Create(filename)
-			if err != nil {
-				printError(cmd, "Error creating result file: %v ❌ ", err)
-				return
-			}
-			defer resultFile.Close()
-
-			if err = cli.agentSDK.Result(cmd.Context(), privKey, resultFile); err != nil {
-				printError(cmd, "Error retrieving computation result: %v ❌ ", err)
-				return
-			}
-
-			cmd.Println(color.New(color.FgGreen).Sprintf("Computation result retrieved and saved successfully as %s! ✔ ", filename))
+			log.Println("Computation result retrieved and saved successfully!")
 		},
 	}
 }
@@ -1,177 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-
-package cli
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/ultravioletrs/cocos/pkg/sdk/mocks"
-)
-
-const compResult = "Test computation result"
-
-func TestResultsCmd_MultipleExecutions(t *testing.T) {
-	mockSDK := new(mocks.SDK)
-	mockSDK.On("Result", mock.Anything, mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
-		_, err := args.Get(2).(*os.File).WriteString(compResult)
-		require.NoError(t, err)
-	})
-	testCLI := CLI{agentSDK: mockSDK}
-
-	err := generateRSAPrivateKeyFile(privateKeyFile)
-	require.NoError(t, err)
-
-	cmd := testCLI.NewResultsCmd()
-	buf := new(bytes.Buffer)
-	cmd.SetOut(buf)
-	cmd.SetArgs([]string{privateKeyFile})
-
-	for i := 0; i < 3; i++ {
-		err = cmd.Execute()
-		require.NoError(t, err)
-		require.Contains(t, buf.String(), "Computation result retrieved and saved successfully")
-		buf.Reset()
-	}
-
-	files, err := filepath.Glob("results*.zip")
-	require.NoError(t, err)
-
-	t.Cleanup(func() {
-		for _, file := range files {
-			os.Remove(file)
-		}
-		os.Remove(privateKeyFile)
-	})
-}
-
-func TestResultsCmd_InvalidPrivateKey(t *testing.T) {
-	mockSDK := new(mocks.SDK)
-	mockSDK.On("Result", mock.Anything, mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
-		_, err := args.Get(2).(*os.File).WriteString(compResult)
-		require.NoError(t, err)
-	})
-	testCLI := CLI{agentSDK: mockSDK}
-
-	invalidPrivateKey, err := os.CreateTemp("", "invalid_private_key.pem")
-	require.NoError(t, err)
-	err = invalidPrivateKey.Close()
-	require.NoError(t, err)
-
-	t.Cleanup(func() {
-		err := os.Remove(invalidPrivateKey.Name())
-		require.NoError(t, err)
-	})
-
-	cmd := testCLI.NewResultsCmd()
-	buf := new(bytes.Buffer)
-	cmd.SetOut(buf)
-	cmd.SetArgs([]string{invalidPrivateKey.Name()})
-	err = cmd.Execute()
-	require.NoError(t, err)
-
-	require.Contains(t, buf.String(), "Error decoding private key")
-	mockSDK.AssertNotCalled(t, "Result", mock.Anything, mock.Anything, mock.Anything)
-}
-
-func TestResultsCmd(t *testing.T) {
-	tests := []struct {
-		name           string
-		setupMock      func(*mocks.SDK)
-		setupFiles     func() (string, error)
-		connectErr     error
-		expectedOutput string
-		cleanup        func()
-	}{
-		{
-			name: "successful result retrieval",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Result", mock.Anything, mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
-					_, err := args.Get(2).(*os.File).WriteString(compResult)
-					require.NoError(t, err)
-				})
-			},
-			setupFiles: func() (string, error) {
-				return privateKeyFile, generateRSAPrivateKeyFile(privateKeyFile)
-			},
-			expectedOutput: "Computation result retrieved and saved successfully",
-			cleanup: func() {
-				files, _ := filepath.Glob("results*.zip")
-				for _, file := range files {
-					os.Remove(file)
-				}
-				os.Remove(privateKeyFile)
-			},
-		},
-		{
-			name: "missing private key file",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Result", mock.Anything, mock.Anything, mock.Anything).Return(nil).Run(func(args mock.Arguments) {
-					_, err := args.Get(2).(*os.File).WriteString(compResult)
-					require.NoError(t, err)
-				})
-			},
-			setupFiles: func() (string, error) {
-				return "non_existent_private_key.pem", nil
-			},
-			expectedOutput: "Error reading private key file",
-		},
-		{
-			name: "result retrieval failure",
-			setupMock: func(m *mocks.SDK) {
-				m.On("Result", mock.Anything, mock.Anything, mock.Anything).Return(errors.New("error retrieving computation result"))
-			},
-			setupFiles: func() (string, error) {
-				return privateKeyFile, generateRSAPrivateKeyFile(privateKeyFile)
-			},
-			expectedOutput: "error retrieving computation result",
-			cleanup: func() {
-				os.Remove(privateKeyFile)
-			},
-		},
-		{
-			name: "connection error",
-			setupMock: func(m *mocks.SDK) {
-			},
-			setupFiles:     func() (string, error) { return "", nil },
-			connectErr:     errors.New("failed to connect to agent"),
-			expectedOutput: "Failed to connect to agent",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			mockSDK := new(mocks.SDK)
-			if tt.setupMock != nil {
-				tt.setupMock(mockSDK)
-			}
-
-			testCLI := CLI{
-				agentSDK:   mockSDK,
-				connectErr: tt.connectErr,
-			}
-
-			file, err := tt.setupFiles()
-			require.NoError(t, err)
-
-			cmd := testCLI.NewResultsCmd()
-			buf := new(bytes.Buffer)
-			cmd.SetOut(buf)
-			cmd.SetArgs([]string{file})
-			err = cmd.Execute()
-			require.NoError(t, err)
-
-			require.Contains(t, buf.String(), tt.expectedOutput)
-
-			if tt.cleanup != nil {
-				tt.cleanup()
-			}
-		})
-	}
-}
@@ -3,42 +3,15 @@
 package cli

 import (
-	"context"
-
-	"github.com/spf13/cobra"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc/agent"
-	"github.com/ultravioletrs/cocos/pkg/sdk"
+	"github.com/ultravioletrs/cocos/agent"
 )

-var Verbose bool
-
 type CLI struct {
-	agentSDK   sdk.SDK
-	config     grpc.AgentClientConfig
-	client     grpc.Client
-	connectErr error
+	agentSDK agent.Service
 }

-func New(config grpc.AgentClientConfig) *CLI {
+func New(agentSDK agent.Service) *CLI {
 	return &CLI{
-		config: config,
+		agentSDK: agentSDK,
 	}
 }
-
-func (c *CLI) InitializeSDK(cmd *cobra.Command) error {
-	agentGRPCClient, agentClient, err := agent.NewAgentClient(context.Background(), c.config)
-	if err != nil {
-		c.connectErr = err
-		return err
-	}
-	cmd.Println("🔗 Connected to agent using ", agentGRPCClient.Secure())
-	c.client = agentGRPCClient
-
-	c.agentSDK = sdk.NewAgentSDK(agentClient)
-	return nil
-}
-
-func (c *CLI) Close() {
-	c.client.Close()
-}
@@ -3,35 +3,22 @@
 package main

 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log"
 	"log/slog"
-	"os"
-	"time"

-	mglog "github.com/absmach/magistrala/logger"
-	"github.com/absmach/magistrala/pkg/prometheus"
-	"github.com/cenkalti/backoff/v4"
-	"github.com/google/go-sev-guest/abi"
-	"github.com/google/go-sev-guest/client"
 	"github.com/mdlayher/vsock"
 	"github.com/ultravioletrs/cocos/agent"
 	"github.com/ultravioletrs/cocos/agent/api"
 	agentgrpc "github.com/ultravioletrs/cocos/agent/api/grpc"
-	"github.com/ultravioletrs/cocos/agent/auth"
 	"github.com/ultravioletrs/cocos/agent/events"
+	"github.com/ultravioletrs/cocos/internal"
 	agentlogger "github.com/ultravioletrs/cocos/internal/logger"
 	"github.com/ultravioletrs/cocos/internal/server"
 	grpcserver "github.com/ultravioletrs/cocos/internal/server/grpc"
-	ackvsock "github.com/ultravioletrs/cocos/internal/vsock"
-	managerevents "github.com/ultravioletrs/cocos/manager/events"
-	"github.com/ultravioletrs/cocos/manager/qemu"
-	"github.com/ultravioletrs/cocos/pkg/attestation/quoteprovider"
-	"golang.org/x/crypto/sha3"
+	"github.com/ultravioletrs/cocos/manager"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
@@ -40,7 +27,6 @@ import (
 const (
 	svcName        = "agent"
 	defSvcGRPCPort = "7002"
-	retryInterval  = 5 * time.Second
 )

 func main() {
@@ -52,92 +38,41 @@ func main() {
 		log.Fatalf("failed to read agent configuration from vsock %s", err.Error())
 	}

-	conn, err := dialVsock()
+	conn, err := vsock.Dial(vsock.Host, manager.ManagerVsockPort, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer conn.Close()
-
-	ackConn := ackvsock.NewAckWriter(conn)
-
-	var exitCode int
-	defer mglog.ExitWithError(&exitCode)
-
 	var level slog.Level
 	if err := level.UnmarshalText([]byte(cfg.AgentConfig.LogLevel)); err != nil {
 		log.Println(err)
-		exitCode = 1
 		return
 	}
-
-	handler := agentlogger.NewProtoHandler(ackConn, &slog.HandlerOptions{Level: level}, cfg.ID)
+	handler := agentlogger.NewProtoHandler(conn, &slog.HandlerOptions{Level: level})
 	logger := slog.New(handler)

-	eventSvc, err := events.New(svcName, cfg.ID, ackConn)
+	eventSvc, err := events.New(svcName, cfg.ID, manager.ManagerVsockPort)
 	if err != nil {
-		logger.Error(fmt.Sprintf("failed to create events service %s", err.Error()))
-		exitCode = 1
+		log.Printf("failed to create events service %s", err.Error())
 		return
 	}
+	defer eventSvc.Close()
+	svc := newService(ctx, logger, eventSvc, cfg)

-	qp, err := quoteprovider.GetQuoteProvider()
-	if err != nil {
-		logger.Error(fmt.Sprintf("failed to create quote provider %s", err.Error()))
-		exitCode = 1
-		return
-	}
-
-	if err := verifyManifest(cfg, qp); err != nil {
-		logger.Error(err.Error())
-		exitCode = 1
-		return
-	}
-
-	setDefaultValues(&cfg)
-
-	svc := newService(ctx, logger, eventSvc, cfg, qp)
-
-	agentGrpcServerConfig := server.AgentConfig{
-		ServerConfig: server.ServerConfig{
-			BaseConfig: server.BaseConfig{
-				Host:         cfg.AgentConfig.Host,
-				Port:         cfg.AgentConfig.Port,
-				CertFile:     cfg.AgentConfig.CertFile,
-				KeyFile:      cfg.AgentConfig.KeyFile,
-				ServerCAFile: cfg.AgentConfig.ServerCAFile,
-				ClientCAFile: cfg.AgentConfig.ClientCAFile,
-			},
-		},
-		AttestedTLS: cfg.AgentConfig.AttestedTls,
+	grpcServerConfig := server.Config{
+		Port:         cfg.AgentConfig.Port,
+		Host:         cfg.AgentConfig.Host,
+		CertFile:     cfg.AgentConfig.CertFile,
+		KeyFile:      cfg.AgentConfig.KeyFile,
+		ServerCAFile: cfg.AgentConfig.ServerCAFile,
+		ClientCAFile: cfg.AgentConfig.ClientCAFile,
 	}

 	registerAgentServiceServer := func(srv *grpc.Server) {
 		reflection.Register(srv)
 		agent.RegisterAgentServiceServer(srv, agentgrpc.NewServer(svc))
 	}
-
-	authSvc, err := auth.New(cfg)
-	if err != nil {
-		logger.Error(fmt.Sprintf("failed to create auth service %s", err.Error()))
-		exitCode = 1
-		return
-	}
-
-	gs := grpcserver.New(ctx, cancel, svcName, agentGrpcServerConfig, registerAgentServiceServer, logger, qp, authSvc)
-
-	g.Go(func() error {
-		for {
-			if _, err := io.Copy(io.Discard, conn); err != nil {
-				log.Printf("vsock connection lost: %v, reconnecting...", err)
-				conn.Close()
-				conn, err = dialVsock()
-				if err != nil {
-					log.Fatal("failed to reconnect: ", err)
-				}
-			}
-			time.Sleep(retryInterval)
-		}
-	})
+	gs := grpcserver.New(ctx, cancel, svcName, grpcServerConfig, registerAgentServiceServer, logger)

 	g.Go(func() error {
 		return gs.Start()
@@ -152,113 +87,43 @@ func main() {
 	}
 }

-func newService(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp agent.Computation, qp client.QuoteProvider) agent.Service {
-	svc := agent.New(ctx, logger, eventSvc, cmp, qp)
+func newService(ctx context.Context, logger *slog.Logger, eventSvc events.Service, cmp agent.Computation) agent.Service {
+	svc := agent.New(ctx, logger, eventSvc, cmp)

 	svc = api.LoggingMiddleware(svc, logger)
-	counter, latency := prometheus.MakeMetrics(svcName, "api")
+	counter, latency := internal.MakeMetrics(svcName, "api")
 	svc = api.MetricsMiddleware(svc, counter, latency)

 	return svc
 }

 func readConfig() (agent.Computation, error) {
-	l, err := vsock.Listen(qemu.VsockConfigPort, nil)
+	l, err := vsock.Listen(manager.VsockConfigPort, nil)
 	if err != nil {
 		return agent.Computation{}, err
 	}
 	defer l.Close()
-
 	conn, err := l.Accept()
 	if err != nil {
 		return agent.Computation{}, err
 	}
 	defer conn.Close()
-
-	var buffer []byte
-	for {
-		chunk := make([]byte, 1024)
-		n, err := conn.Read(chunk)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return agent.Computation{}, err
-		}
-		buffer = append(buffer, chunk[:n]...)
+	b := make([]byte, 1024)
+	n, err := conn.Read(b)
+	if err != nil {
+		return agent.Computation{}, err
 	}
-
 	ac := agent.Computation{
 		AgentConfig: agent.AgentConfig{},
 	}
-	if err := json.Unmarshal(buffer, &ac); err != nil {
+	if err := json.Unmarshal(b[:n], &ac); err != nil {
 		return agent.Computation{}, err
 	}
+	if ac.AgentConfig.LogLevel == "" {
+		ac.AgentConfig.LogLevel = "info"
+	}
+	if ac.AgentConfig.Port == "" {
+		ac.AgentConfig.Port = defSvcGRPCPort
+	}
 	return ac, nil
 }
-
-func setDefaultValues(cfg *agent.Computation) {
-	if cfg.AgentConfig.LogLevel == "" {
-		cfg.AgentConfig.LogLevel = "info"
-	}
-	if cfg.AgentConfig.Port == "" {
-		cfg.AgentConfig.Port = defSvcGRPCPort
-	}
-}
-
-func isTEE() bool {
-	_, err := os.Stat("/dev/sev-guest")
-	return !os.IsNotExist(err)
-}
-
-func dialVsock() (*vsock.Conn, error) {
-	var conn *vsock.Conn
-	var err error
-
-	err = backoff.Retry(func() error {
-		conn, err = vsock.Dial(vsock.Host, managerevents.ManagerVsockPort, nil)
-		if err == nil {
-			log.Println("vsock connection established")
-			return nil
-		}
-		log.Printf("vsock connection failed, retrying in %s... Error: %v", retryInterval, err)
-		return err
-	}, backoff.NewExponentialBackOff())
-	if err != nil {
-		return nil, err
-	}
-
-	return conn, nil
-}
-
-func verifyManifest(cfg agent.Computation, qp client.QuoteProvider) error {
-	if !isTEE() {
-		return nil
-	}
-
-	ar, err := qp.GetRawQuote(sha3.Sum512([]byte(cfg.ID)))
-	if err != nil {
-		return err
-	}
-
-	arProto, err := abi.ReportCertsToProto(ar[:abi.ReportSize])
-	if err != nil {
-		return err
-	}
-
-	cfgBytes, err := json.Marshal(cfg)
-	if err != nil {
-		return err
-	}
-
-	mcHash := sha3.Sum256(cfgBytes)
-
-	if arProto.Report.HostData == nil {
-		return fmt.Errorf("manifest verification failed: HostData is nil")
-	}
-	if !bytes.Equal(arProto.Report.HostData, mcHash[:]) {
-		return fmt.Errorf("manifest verification failed")
-	}
-
-	return nil
-}
@@ -1,94 +0,0 @@
-// Copyright (c) Ultraviolet
-// SPDX-License-Identifier: Apache-2.0
-package main
-
-import (
-	"context"
-	"log/slog"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/agent"
-	"github.com/ultravioletrs/cocos/agent/events/mocks"
-	qpmocks "github.com/ultravioletrs/cocos/pkg/attestation/quoteprovider/mocks"
-)
-
-func TestSetDefaultValues(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    agent.Computation
-		expected agent.Computation
-	}{
-		{
-			name: "Empty config",
-			input: agent.Computation{
-				AgentConfig: agent.AgentConfig{},
-			},
-			expected: agent.Computation{
-				AgentConfig: agent.AgentConfig{
-					LogLevel: "info",
-					Port:     "7002",
-				},
-			},
-		},
-		{
-			name: "Partial config",
-			input: agent.Computation{
-				AgentConfig: agent.AgentConfig{
-					LogLevel: "debug",
-				},
-			},
-			expected: agent.Computation{
-				AgentConfig: agent.AgentConfig{
-					LogLevel: "debug",
-					Port:     "7002",
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			setDefaultValues(&tt.input)
-			assert.Equal(t, tt.expected, tt.input)
-		})
-	}
-}
-
-func TestNewService(t *testing.T) {
-	ctx := context.Background()
-	logger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-	eventSvc := new(mocks.Service)
-	eventSvc.On("SendEvent", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	cmp := agent.Computation{
-		ID: "test-computation",
-		AgentConfig: agent.AgentConfig{
-			LogLevel: "info",
-			Port:     "7002",
-		},
-	}
-	qp := new(qpmocks.QuoteProvider)
-
-	svc := newService(ctx, logger, eventSvc, cmp, qp)
-
-	assert.NotNil(t, svc)
-}
-
-func TestVerifyManifest(t *testing.T) {
-	cfg := agent.Computation{
-		ID: "test-computation",
-		AgentConfig: agent.AgentConfig{
-			LogLevel: "info",
-			Port:     "7002",
-		},
-	}
-
-	mockQP := new(qpmocks.QuoteProvider)
-	mockQP.On("GetRawQuote", mock.Anything).Return([]byte{}, nil)
-
-	err := verifyManifest(cfg, mockQP)
-
-	assert.NoError(t, err)
-}
@@ -4,33 +4,57 @@ package main

 import (
 	"fmt"
+	"log"
 	"os"
-	"os/signal"
-	"path"
-	"syscall"

-	"github.com/caarlos0/env/v11"
-	"github.com/fatih/color"
+	mglog "github.com/absmach/magistrala/logger"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"github.com/ultravioletrs/cocos/cli"
+	"github.com/ultravioletrs/cocos/internal/env"
 	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
-	cmd "github.com/virtee/sev-snp-measure-go/sevsnpmeasure/cmd"
+	"github.com/ultravioletrs/cocos/pkg/clients/grpc/agent"
+	"github.com/ultravioletrs/cocos/pkg/sdk"
 )

 const (
 	svcName            = "cli"
 	envPrefixAgentGRPC = "AGENT_GRPC_"
 	completion         = "completion"
-	filePermision      = 0o755
-	cocosDirectory     = ".cocos"
 )

 type config struct {
-	LogLevel string `env:"AGENT_LOG_LEVEL" envDefault:"info"`
+	LogLevel string `env:"AGENT_LOG_LEVEL"               envDefault:"info"`
 }

 func main() {
+	var cfg config
+	if err := env.Parse(&cfg); err != nil {
+		log.Fatalf("failed to load %s configuration : %s", svcName, err)
+	}
+
+	logger, err := mglog.New(os.Stdout, cfg.LogLevel)
+	if err != nil {
+		log.Fatalf("Error creating logger: %s", err)
+	}
+
+	agentGRPCConfig := grpc.Config{}
+	if err := env.Parse(&agentGRPCConfig, env.Options{Prefix: envPrefixAgentGRPC}); err != nil {
+		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
+		return
+	}
+
+	agentGRPCClient, agentClient, err := agent.NewAgentClient(agentGRPCConfig)
+	if err != nil {
+		logger.Error(err.Error())
+		return
+	}
+	defer agentGRPCClient.Close()
+
+	agentSDK := sdk.NewAgentSDK(logger, agentClient)
+
+	cliSVC := cli.New(agentSDK)
+
 	rootCmd := &cobra.Command{
 		Use:   "cocos-cli [command]",
 		Short: "CLI application for CoCos Service API",
@@ -59,96 +83,19 @@ func main() {
 		},
 	}

-	signalChan := make(chan os.Signal, 1)
-	signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
-
-	go func() {
-		<-signalChan
-		fmt.Println()
-		rootCmd.Println(color.New(color.FgRed).Sprint("Operation aborted by user!"))
-		os.Exit(2)
-	}()
-
-	var cfg config
-	if err := env.Parse(&cfg); err != nil {
-		message := color.New(color.FgRed).Sprintf("failed to load %s configuration : %s", svcName, err)
-		rootCmd.Println(message)
-		return
-	}
-
-	homePath, err := os.UserHomeDir()
-	if err != nil {
-		message := color.New(color.FgRed).Sprintf("failed to fetch user home directory: %s", err)
-		rootCmd.Println(message)
-		return
-	}
-
-	directoryCachePath := path.Join(homePath, cocosDirectory)
-
-	if err := os.MkdirAll(directoryCachePath, filePermision); err != nil {
-		message := color.New(color.FgRed).Sprintf("failed to create directory %s : %s", directoryCachePath, err)
-		rootCmd.Println(message)
-		return
-	}
-
-	agentGRPCConfig := grpc.AgentClientConfig{}
-	if err := env.ParseWithOptions(&agentGRPCConfig, env.Options{Prefix: envPrefixAgentGRPC}); err != nil {
-		message := color.New(color.FgRed).Sprintf("failed to load %s gRPC client configuration : %s", svcName, err)
-		rootCmd.Println(message)
-		return
-	}
-
-	cliSVC := cli.New(agentGRPCConfig)
-
-	if err := cliSVC.InitializeSDK(rootCmd); err == nil {
-		defer cliSVC.Close()
-	}
-
-	rootCmd.PersistentFlags().BoolVarP(&cli.Verbose, "verbose", "v", false, "Enable verbose output")
-
-	keysCmd := cliSVC.NewKeysCmd()
-	attestationCmd := cliSVC.NewAttestationCmd()
-	attestationPolicyCmd := cliSVC.NewAttestationPolicyCmd()
-
 	// Agent Commands
-	rootCmd.AddCommand(cliSVC.NewAlgorithmCmd())
+	rootCmd.AddCommand(cliSVC.NewAlgorithmsCmd())
 	rootCmd.AddCommand(cliSVC.NewDatasetsCmd())
 	rootCmd.AddCommand(cliSVC.NewResultsCmd())
-	rootCmd.AddCommand(attestationCmd)
-	rootCmd.AddCommand(cliSVC.NewFileHashCmd())
-	rootCmd.AddCommand(attestationPolicyCmd)
-	rootCmd.AddCommand(keysCmd)
-	rootCmd.AddCommand(cliSVC.NewCABundleCmd(directoryCachePath))
+	attestaionCmd := cliSVC.NewAttestationCmd()
+	rootCmd.AddCommand(attestaionCmd)

 	// Attestation commands
-	attestationCmd.AddCommand(cliSVC.NewGetAttestationCmd())
-	attestationCmd.AddCommand(cliSVC.NewValidateAttestationValidationCmd())
-
-	// measure.
-	rootCmd.AddCommand(cmd.NewRootCmd())
-
-	// Flags
-	keysCmd.PersistentFlags().StringVarP(
-		&cli.KeyType,
-		"key-type",
-		"k",
-		"rsa",
-		"User Key type",
-	)
-
-	// Attestation Policy commands
-	attestationPolicyCmd.AddCommand(cliSVC.NewAddMeasurementCmd())
-	attestationPolicyCmd.AddCommand(cliSVC.NewAddHostDataCmd())
+	attestaionCmd.AddCommand(cliSVC.NewGetAttestationCmd())
+	attestaionCmd.AddCommand(cliSVC.NewValidateAttestationValidationCmd())

 	if err := rootCmd.Execute(); err != nil {
-		logErrorCmd(*rootCmd, err)
+		logger.Error(fmt.Sprintf("Command execution failed: %s", err))
 		return
 	}
 }
-
-func logErrorCmd(cmd cobra.Command, err error) {
-	boldRed := color.New(color.FgRed, color.Bold)
-	boldRed.Fprintf(cmd.ErrOrStderr(), "\nerror: ")
-
-	fmt.Fprintf(cmd.ErrOrStderr(), "%s\n\n", color.RedString(err.Error()))
-}
@@ -8,47 +8,40 @@ import (
 	"fmt"
 	"log"
 	"log/slog"
-	"net/url"
 	"os"
-	"os/signal"
 	"strings"
-	"syscall"

 	mglog "github.com/absmach/magistrala/logger"
-	"github.com/absmach/magistrala/pkg/jaeger"
-	"github.com/absmach/magistrala/pkg/prometheus"
 	"github.com/absmach/magistrala/pkg/uuid"
-	"github.com/caarlos0/env/v11"
+	"github.com/ultravioletrs/cocos/internal"
+	"github.com/ultravioletrs/cocos/internal/env"
+	jaegerclient "github.com/ultravioletrs/cocos/internal/jaeger"
 	"github.com/ultravioletrs/cocos/manager"
 	"github.com/ultravioletrs/cocos/manager/api"
 	managerapi "github.com/ultravioletrs/cocos/manager/api/grpc"
-	"github.com/ultravioletrs/cocos/manager/events"
 	"github.com/ultravioletrs/cocos/manager/qemu"
 	"github.com/ultravioletrs/cocos/manager/tracing"
-	pkggrpc "github.com/ultravioletrs/cocos/pkg/clients/grpc"
+	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
 	managergrpc "github.com/ultravioletrs/cocos/pkg/clients/grpc/manager"
+	pkgmanager "github.com/ultravioletrs/cocos/pkg/manager"
 	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/sync/errgroup"
 )

 const (
-	svcName          = "manager"
-	envPrefixGRPC    = "MANAGER_GRPC_"
-	envPrefixQemu    = "MANAGER_QEMU_"
-	clientBufferSize = 100
+	svcName       = "manager"
+	envPrefixGRPC = "MANAGER_GRPC_"
+	envPrefixQemu = "MANAGER_QEMU_"
 )

 type config struct {
-	LogLevel                string  `env:"MANAGER_LOG_LEVEL"                  envDefault:"info"`
-	JaegerURL               url.URL `env:"COCOS_JAEGER_URL"                   envDefault:"http://localhost:4318"`
-	TraceRatio              float64 `env:"COCOS_JAEGER_TRACE_RATIO"           envDefault:"1.0"`
-	InstanceID              string  `env:"MANAGER_INSTANCE_ID"                envDefault:""`
-	AttestationPolicyBinary string  `env:"MANAGER_ATTESTATION_POLICY_BINARY"  envDefault:"../../build"`
-	EosVersion              string  `env:"MANAGER_EOS_VERSION"                envDefault:""`
+	LogLevel   string `env:"MANAGER_LOG_LEVEL"        envDefault:"info"`
+	JaegerURL  string `env:"COCOS_JAEGER_URL"         envDefault:"http://localhost:14268/api/traces"`
+	InstanceID string `env:"MANAGER_INSTANCE_ID"      envDefault:""`
 }

 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx := context.Background()
 	g, ctx := errgroup.WithContext(ctx)

 	var cfg config
@@ -58,21 +51,18 @@ func main() {

 	logger, err := mglog.New(os.Stdout, cfg.LogLevel)
 	if err != nil {
-		log.Fatal(err.Error())
+		log.Fatalf(err.Error())
 	}

-	var exitCode int
-	defer mglog.ExitWithError(&exitCode)
-
 	if cfg.InstanceID == "" {
-		if cfg.InstanceID, err = uuid.New().ID(); err != nil {
+		cfg.InstanceID, err = uuid.New().ID()
+		if err != nil {
 			logger.Error(fmt.Sprintf("Failed to generate instance ID: %s", err))
-			exitCode = 1
 			return
 		}
 	}

-	tp, err := jaeger.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID, cfg.TraceRatio)
+	tp, err := jaegerclient.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
 	}
@@ -84,25 +74,26 @@ func main() {
 	tracer := tp.Tracer(svcName)

 	qemuCfg := qemu.Config{}
-	if err := env.ParseWithOptions(&qemuCfg, env.Options{Prefix: envPrefixQemu}); err != nil {
+	if err := env.Parse(&qemuCfg, env.Options{Prefix: envPrefixQemu}); err != nil {
 		logger.Error(fmt.Sprintf("failed to load QEMU configuration: %s", err))
-		exitCode = 1
 		return
 	}
-	args := qemuCfg.ConstructQemuArgs()
-	logger.Info(strings.Join(args, " "))
+	exe, args, err := qemu.ExecutableAndArgs(qemuCfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("failed to parse QEMU configuration: %s", err))
+		return
+	}
+	logger.Info(fmt.Sprintf("%s %s", exe, strings.Join(args, " ")))

-	managerGRPCConfig := pkggrpc.ManagerClientConfig{}
-	if err := env.ParseWithOptions(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
+	managerGRPCConfig := grpc.Config{}
+	if err := env.Parse(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
 		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
-		exitCode = 1
 		return
 	}

 	managerGRPCClient, managerClient, err := managergrpc.NewManagerClient(managerGRPCConfig)
 	if err != nil {
 		logger.Error(err.Error())
-		exitCode = 1
 		return
 	}
 	defer managerGRPCClient.Close()
@@ -110,62 +101,39 @@ func main() {
 	pc, err := managerClient.Process(ctx)
 	if err != nil {
 		logger.Error(err.Error())
-		exitCode = 1
 		return
 	}
-
-	eventsChan := make(chan *manager.ClientStreamMessage, clientBufferSize)
-	svc, err := newService(logger, tracer, qemuCfg, eventsChan, cfg.AttestationPolicyBinary, cfg.EosVersion)
-	if err != nil {
+	if err := pc.Send(&pkgmanager.ClientStreamMessage{Message: &pkgmanager.ClientStreamMessage_Whoami{}}); err != nil {
 		logger.Error(err.Error())
-		exitCode = 1
 		return
 	}

-	eventsSvc, err := events.New(logger, svc.ReportBrokenConnection, eventsChan)
-	if err != nil {
-		logger.Error(err.Error())
-		exitCode = 1
-		return
-	}
+	eventsChan := make(chan *pkgmanager.ClientStreamMessage)
+	svc := newService(logger, tracer, qemuCfg, eventsChan)

-	go eventsSvc.Listen(ctx)
-
-	mc := managerapi.NewClient(pc, svc, eventsChan, logger)
+	mc := managerapi.NewClient(pc, svc, eventsChan)

 	g.Go(func() error {
-		ch := make(chan os.Signal, 1)
-		signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
-		defer signal.Stop(ch)
-
-		select {
-		case <-ch:
-			logger.Info("Received signal, shutting down...")
-			cancel()
-			return nil
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	})
-
-	g.Go(func() error {
-		return mc.Process(ctx, cancel)
+		return mc.Process(ctx)
 	})

 	if err := g.Wait(); err != nil {
 		logger.Error(fmt.Sprintf("%s service terminated: %s", svcName, err))
 	}
+
+	err = internal.DeleteFilesInDir(qemuCfg.TmpFileLoc)
+	if err != nil {
+		logger.Error(err.Error())
+	}
 }

-func newService(logger *slog.Logger, tracer trace.Tracer, qemuCfg qemu.Config, eventsChan chan *manager.ClientStreamMessage, attestationPolicyPath string, eosVersion string) (manager.Service, error) {
-	svc, err := manager.New(qemuCfg, attestationPolicyPath, logger, eventsChan, qemu.NewVM, eosVersion)
-	if err != nil {
-		return nil, err
-	}
+func newService(logger *slog.Logger, tracer trace.Tracer, qemuCfg qemu.Config, eventsChan chan *pkgmanager.ClientStreamMessage) manager.Service {
+	svc := manager.New(qemuCfg, logger, eventsChan)
+	go svc.RetrieveAgentEventsLogs()
 	svc = api.LoggingMiddleware(svc, logger)
-	counter, latency := prometheus.MakeMetrics(svcName, "api")
+	counter, latency := internal.MakeMetrics(svcName, "api")
 	svc = api.MetricsMiddleware(svc, counter, latency)
 	svc = tracing.New(svc, tracer)

-	return svc, nil
+	return svc
 }
@@ -0,0 +1,270 @@
+#!/bin/bash
+
+#
+# user changeable parameters
+#
+
+HDA_FILE="cmd/manager/img/focal-server-cloudimg-amd64.qcow2"
+GUEST_SIZE_IN_MB="4096"
+SEV_GUEST="1"
+SMP_NCPUS="4"
+CONSOLE="serial"
+VNC_PORT=""
+USE_VIRTIO="1"
+
+UEFI_BIOS_CODE="/usr/share/OVMF/OVMF_CODE.fd"
+UEFI_BIOS_VARS_ORIG="/usr/share/OVMF/OVMF_VARS.fd"
+UEFI_BIOS_VARS_COPY="cmd/manager/img/OVMF_VARS.fd"
+
+CBITPOS=51
+HOST_HTTP_PORT=9301
+GUEST_HTTP_PORT=9031
+HOST_GRPC_PORT=7020
+GUEST_GRPC_PORT=7002
+
+ENABLE_FILE_LOG="0"
+EXEC_QEMU_CMDLINE="0"
+
+usage() {
+    echo "$0 [options]"
+    echo "Available <commands>:"
+    echo " -hda           hard disk ($HDA_FILE)"
+    echo " -nosev         disable sev support"
+    echo " -mem           guest memory"
+    echo " -smp           number of cpus"
+    echo " -console       display console to use (serial or gxl)"
+    echo " -vnc           VNC port to use"
+    echo " -bios          bios to use (default $UEFI_BIOS_CODE)"
+    echo " -kernel        kernel to use"
+    echo " -initrd        initrd to use"
+    echo " -cdrom         CDROM image"
+    echo " -virtio        use virtio devices"
+    echo " -cbitpos       location of the C-bit"
+    echo " -hosthttp      host http port"
+    echo " -guesthttp     guest http port"
+    echo " -hostgrpc      host grpc port"
+    echo " -guestgrpc     guest grpc port"
+    echo " -origuefivars  UEFI BIOS vars original file (default $UEFI_BIOS_VARS_ORIG)"
+    echo " -copyuefivars  UEFI BIOS vars copy file (default $UEFI_BIOS_VARS_COPY)"
+    echo " -exec          execute the QEMU command (default $EXEC_QEMU_CMDLINE)"
+    echo " -filelog       enable/disable QEMU cmd line file log (default: $ENABLE_FILE_LOG)"
+    exit 1
+}
+
+while [[ $1 != "" ]]; do
+    case "$1" in
+        -hda)
+            HDA_FILE=${2}
+            shift
+            ;;
+        -nosev)
+            SEV_GUEST="0"
+            ;;
+        -mem)
+            GUEST_SIZE_IN_MB=${2}
+            shift
+            ;;
+        -console)
+            CONSOLE=${2}
+            shift
+            ;;
+        -smp)
+            SMP_NCPUS=$2
+            shift
+            ;;
+        -vnc)
+            VNC_PORT=$2
+            shift
+            ;;
+        -bios)
+            UEFI_BIOS_CODE=$2
+            shift
+            ;;
+        -initrd)
+            INITRD_FILE=$2
+            shift
+            ;;
+        -kernel)
+            KERNEL_FILE=$2
+            shift
+            ;;
+        -cdrom)
+            CDROM_FILE=$2
+            shift
+            ;;
+        -virtio)
+            USE_VIRTIO="1"
+            ;;
+        -cbitpos)
+            CBITPOS=$2
+            shift
+            ;;
+        -hosthttp)
+            HOST_HTTP_PORT=$2
+            shift
+            ;;
+        -guesthttp)
+            GUEST_HTTP_PORT=$2
+            shift
+            ;;
+        -guestgrpc)
+            GUEST_GRPC_PORT=$2
+            shift
+            ;;
+        -hostgrpc)
+            HOST_GRPC_PORT=$2
+            shift
+            ;;
+        -origuefivars)
+            UEFI_BIOS_VARS_ORIG=$2
+            shift
+            ;;
+        -copyuefivars)
+            UEFI_BIOS_VARS_COPY=$2
+            shift
+            ;;        
+        -exec)
+            EXEC_QEMU_CMDLINE="1"
+            ;;      
+        -filelog)
+            ENABLE_FILE_LOG="1"
+            ;;                           
+        *)
+            usage;;
+    esac
+    shift
+done
+
+#
+# func definitions
+#
+
+add_opts() {
+    echo -n "$* " >> ${QEMU_CMDLINE}
+}
+
+run_cmd() {
+    if ! "$@"; then
+        echo "Command '$*' failed"
+        exit 1
+    fi
+}
+
+# copy BIOS variables to new dest for VM use without modifying the original ones
+cp "$UEFI_BIOS_VARS_ORIG" "$UEFI_BIOS_VARS_COPY"
+
+#
+# Qemu cmd line construction
+#
+
+# we add all the qemu command line options into a file
+QEMU_CMDLINE=/tmp/cmdline.$$
+rm -rf ${QEMU_CMDLINE}
+
+add_opts "$(which qemu-system-x86_64)"
+
+# Basic virtual machine property
+add_opts "-enable-kvm -cpu EPYC -machine q35"
+
+# add number of VCPUs
+[ -n "$SMP_NCPUS" ] && add_opts "-smp ${SMP_NCPUS},maxcpus=64"
+
+# define guest memory
+add_opts "-m ${GUEST_SIZE_IN_MB}M,slots=5,maxmem=30G"
+
+# The OVMF binary, including the non-volatile variable store, appears as a
+# "normal" qemu drive on the host side, and it is exposed to the guest as a
+# persistent flash device.
+add_opts "-drive if=pflash,format=raw,unit=0,file=${UEFI_BIOS_CODE},readonly=on"
+add_opts "-drive if=pflash,format=raw,unit=1,file=${UEFI_BIOS_VARS_COPY}"
+
+# add CDROM if specified
+[ -n "$CDROM_FILE" ] && add_opts "-drive file=${CDROM_FILE},media=cdrom -boot d"
+
+add_opts "-netdev user,id=vmnic,hostfwd=tcp::2222-:22,hostfwd=tcp::$HOST_HTTP_PORT-:$GUEST_HTTP_PORT,hostfwd=tcp::$HOST_GRPC_PORT-:$GUEST_GRPC_PORT"
+add_opts "-device virtio-net-pci,disable-legacy=on,iommu_platform=true,netdev=vmnic,romfile="
+
+# If harddisk file is specified then add the HDD drive
+if [ -n "$HDA_FILE" ]; then
+    if [ "$USE_VIRTIO" = "1" ]; then
+        if [[ ${HDA_FILE} = *"qcow2" ]]; then
+            add_opts "-drive file=${HDA_FILE},if=none,id=disk0,format=qcow2"
+        else
+            add_opts "-drive file=${HDA_FILE},if=none,id=disk0,format=raw"
+        fi
+        add_opts "-device virtio-scsi-pci,id=scsi,disable-legacy=on,iommu_platform=true"
+        add_opts "-device scsi-hd,drive=disk0"
+    else
+        if [[ ${HDA_FILE} = *"qcow2" ]]; then
+            add_opts "-drive file=${HDA_FILE},format=qcow2"
+        else
+            add_opts "-drive file=${HDA_FILE},format=raw"
+        fi
+    fi
+fi
+
+# If this is SEV guest then add the encryption device objects to enable support
+if [ ${SEV_GUEST} = "1" ]; then
+    add_opts "-object sev-guest,id=sev0,cbitpos=${CBITPOS},reduced-phys-bits=1"
+    add_opts "-machine memory-encryption=sev0"
+fi
+
+# if console is serial then disable graphical interface
+if [ "${CONSOLE}" = "serial" ]; then
+    add_opts "-nographic"
+else
+    add_opts "-vga ${CONSOLE}"
+fi
+
+# if -kernel arg is specified then use the kernel provided in command line for boot
+if [ "${KERNEL_FILE}" != "" ]; then
+    add_opts "-kernel $KERNEL_FILE"
+    add_opts "-append \"console=ttyS0 earlyprintk=serial root=/dev/sda2\""
+    [ -n "$INITRD_FILE" ] && add_opts "-initrd ${INITRD_FILE}"
+fi
+
+# start vnc server
+[ -n "$VNC_PORT" ] && add_opts "-vnc :${VNC_PORT}" && echo "Starting VNC on port ${VNC_PORT}"
+
+# start monitor on pty
+add_opts "-monitor pty"
+
+#
+# Qemu cmd line log
+#
+
+# Set the log file path if ENABLE_FILE_LOG is 1
+if [ "$ENABLE_FILE_LOG" = "1" ]; then
+    LOG_FILE=$(pwd)/stdout.log
+
+    # Save the command line args into log file
+    cat "$QEMU_CMDLINE" > "$LOG_FILE"
+    echo >> "$LOG_FILE"
+fi
+
+ # Log the command line to the console
+cat "$QEMU_CMDLINE"
+
+#
+# Qemu cmd line execution
+#
+
+if [[ "${EXEC_QEMU_CMDLINE}" = "0" ]]; then
+    exit 0
+fi
+
+# map CTRL-C to CTRL ]
+echo "Mapping CTRL-C to CTRL-]"
+stty intr ^]
+
+echo "Launching VM ..."
+if [ "$ENABLE_FILE_LOG" = "1" ]; then
+    bash ${QEMU_CMDLINE} 2>&1 | tee -a "${LOG_FILE}"
+else 
+    bash ${QEMU_CMDLINE} 2>&1
+fi
+
+# restore the mapping
+stty intr ^c
+
+rm -rf ${QEMU_CMDLINE}
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# Set your default values for sudo and sev
+sudo_option=false
+sev_option=false
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    key="$1"
+
+    case $key in
+        --sudo)
+            sudo_option=true
+            shift
+            ;;
+        --sev)
+            sev_option=true
+            shift
+            ;;
+        *)
+            echo "Unknown option: $key"
+            exit 1
+            ;;
+    esac
+done
+
+build_qemu_command() {
+    local qemu_command="/usr/bin/qemu-system-x86_64 -enable-kvm -machine q35 -cpu EPYC -smp 4,maxcpus=64 -m 2048M,slots=5,maxmem=30G -drive if=pflash,format=raw,unit=0,file=$MANAGER_QEMU_OVMF_CODE_FILE,readonly=on -drive if=pflash,format=raw,unit=1,file=img/OVMF_VARS.fd -device virtio-scsi-pci,id=scsi,disable-legacy=on,iommu_platform=true -drive file=img/focal-server-cloudimg-amd64.img,if=none,id=disk0,format=qcow2 -device scsi-hd,drive=disk0 -netdev user,id=vmnic,hostfwd=tcp::2222-:22,hostfwd=tcp::9301-:9031,hostfwd=tcp::7020-:7002 -device virtio-net-pci,disable-legacy=on,iommu_platform=true,netdev=vmnic,romfile= -nographic -monitor pty"
+
+    if [ "$sev_option" = true ]; then
+        qemu_command="$qemu_command -object sev-guest,id=sev0,cbitpos=51,reduced-phys-bits=1 -machine memory-encryption=sev0"
+    fi
+
+    echo "$qemu_command"
+}
+
+if [ ! -f "img/OVMF_VARS.fd" ]; then
+    cp "$MANAGER_QEMU_OVMF_VARS_FILE" "img/OVMF_VARS.fd"
+    echo "Copied $MANAGER_QEMU_OVMF_VARS_FILE to img/OVMF_VARS.fd"
+else
+    echo "img/OVMF_VARS.fd already exists. No need to copy."
+fi
+
+echo "Launching VM ..."
+
+qemu_command=$(build_qemu_command)
+echo "$qemu_command"
+
+echo "Mapping CTRL-C to CTRL-]"
+stty intr ^]
+
+if [ "$sudo_option" = true ]; then
+    # Split the command and arguments into an array; << operator is known as a "here string"
+    IFS=" " read -r -a qemu_command_array <<< "$qemu_command"
+    # Treat each element in the array as a separate word, preserving spaces within each element
+    sudo "${qemu_command_array[@]}"
+else
+    $qemu_command
+fi
+
+# Restore the mapping
+stty intr ^c
@@ -0,0 +1,62 @@
+<domain type="kvm">
+  <name>QEmu-alpine-standard-x86_64</name>
+  <uuid>c7a5fdbd-cdaf-9455-926a-d65c16db1809</uuid>
+  <metadata>
+    <libosinfo:libosinfo xmlns:libosinfo="http://libosinfo.org/xmlns/libvirt/domain/1.0">
+      <libosinfo:os id="http://alpinelinux.org/alpinelinux/3.15"/>
+    </libosinfo:libosinfo>
+  </metadata>
+  <memory unit="KiB">4194304</memory>
+  <currentMemory unit="KiB">4194304</currentMemory>
+  <vcpu placement="static">1</vcpu>
+  <os>
+    <type arch="x86_64" machine="q35">hvm</type>
+    <bootmenu enable="yes"/>
+    <loader readonly="yes" type="pflash">/usr/share/OVMF/OVMF_CODE.fd</loader>
+    <nvram template='/usr/share/OVMF/OVMF_VARS.fd'>./img/OVMF_VARS.fd</nvram>
+    <!-- <boot dev='hd'/> -->
+  </os>
+  <features>
+    <acpi/>
+    <apic/>
+    <vmport state="off"/>
+  </features>
+  <cpu mode="host-passthrough" check="none" migratable="on"/>
+  <clock offset="utc">
+    <timer name="rtc" tickpolicy="catchup"/>
+    <timer name="pit" tickpolicy="delay"/>
+    <timer name="hpet" present="no"/>
+  </clock>
+  <on_poweroff>destroy</on_poweroff>
+  <on_reboot>restart</on_reboot>
+  <on_crash>destroy</on_crash>
+  <pm>
+    <suspend-to-mem enabled="no"/>
+    <suspend-to-disk enabled="no"/>
+  </pm>
+  <devices>
+    <emulator>/usr/bin/qemu-system-x86_64</emulator>
+    <disk type="file" device="disk">
+      <driver name="qemu" type="qcow2" discard="unmap"/>
+      <source file="./img/focal-server-cloudimg-amd64.qcow2"/>
+      <target dev="vda" bus="virtio"/>
+      <address type="pci" domain="0x0000" bus="0x04" slot="0x00" function="0x0"/>
+      <boot order="1"/>
+    </disk>
+    <graphics type="spice" autoport="yes">
+      <listen type="address"/>
+      <image compression="off"/>
+    </graphics>
+    <video>
+      <model type="qxl" ram="65536" vram="65536" vgamem="16384" heads="1" primary="yes"/>
+      <address type="pci" domain="0x0000" bus="0x00" slot="0x01" function="0x0"/>
+    </video>
+    <interface type="network">
+      <mac address="52:54:00:03:7b:5f"/>
+      <source network="default"/>
+      <model type="virtio"/>
+      <address type="pci" domain="0x0000" bus="0x01" slot="0x00" function="0x0"/>
+    </interface>
+  </devices>
+
+</domain>
@@ -0,0 +1,6 @@
+<pool type="dir">
+<name>virtimages</name>
+<target>
+  <path>./img</path>
+</target>
+</pool>
@@ -0,0 +1,15 @@
+<volume>
+<name>boot.img</name>
+<allocation>0</allocation>
+<capacity unit="G">1</capacity>
+<target>
+  <format type="qcow2"/>
+  <path>./img/boot.img</path>
+  <permissions>
+	<owner>107</owner>
+	<group>107</group>
+	<mode>0744</mode>
+	<label>virt_image_t</label>
+  </permissions>
+</target>
+</volume>
@@ -1,60 +0,0 @@
-# Environment Configuration for Cocos
-
-# Jaeger Tracing
-COCOS_JAEGER_URL=http://localhost:4318
-COCOS_JAEGER_TRACE_RATIO=1.0
-
-# Manager Service Configuration
-MANAGER_INSTANCE_ID=
-MANAGER_ATTESTATION_POLICY_BINARY=../../build
-MANAGER_GRPC_CLIENT_CERT=
-MANAGER_GRPC_CLIENT_KEY=
-MANAGER_GRPC_SERVER_CA_CERTS=
-MANAGER_GRPC_URL=localhost:7001
-MANAGER_GRPC_TIMEOUT=60s
-MANAGER_EOS_VERSION=""
-
-# QEMU Configuration
-MANAGER_QEMU_MEMORY_SIZE=25G
-MANAGER_QEMU_MEMORY_SLOTS=5
-MANAGER_QEMU_MAX_MEMORY=30G
-MANAGER_QEMU_OVMF_CODE_IF=pflash
-MANAGER_QEMU_OVMF_CODE_FORMAT=raw
-MANAGER_QEMU_OVMF_CODE_UNIT=0
-MANAGER_QEMU_OVMF_CODE_FILE=/usr/share/OVMF/x64/OVMF_CODE.fd
-MANAGER_QEMU_OVMF_VERSION=edk2-stable202408
-MANAGER_QEMU_OVMF_CODE_READONLY=on
-MANAGER_QEMU_OVMF_VARS_IF=pflash
-MANAGER_QEMU_OVMF_VARS_FORMAT=raw
-MANAGER_QEMU_OVMF_VARS_UNIT=1
-MANAGER_QEMU_OVMF_VARS_FILE=/usr/share/OVMF/x64/OVMF_VARS.fd
-MANAGER_QEMU_NETDEV_ID=vmnic
-MANAGER_QEMU_HOST_FWD_AGENT=7020
-MANAGER_QEMU_GUEST_FWD_AGENT=7002
-MANAGER_QEMU_VIRTIO_NET_PCI_DISABLE_LEGACY=on
-MANAGER_QEMU_VIRTIO_NET_PCI_IOMMU_PLATFORM=true
-MANAGER_QEMU_VIRTIO_NET_PCI_ADDR=0x2
-MANAGER_QEMU_VIRTIO_NET_PCI_ROMFILE=
-MANAGER_QEMU_DISK_IMG_KERNEL_FILE=/home/sammyk/Documents/cocos-ai/cmd/manager/img/bzImage
-MANAGER_QEMU_DISK_IMG_ROOTFS_FILE=/home/sammyk/Documents/cocos-ai/cmd/manager/img/rootfs.cpio.gz
-MANAGER_QEMU_SEV_ID=sev0
-MANAGER_QEMU_SEV_CBITPOS=51
-MANAGER_QEMU_SEV_REDUCED_PHYS_BITS=1
-MANAGER_QEMU_HOST_DATA=
-MANAGER_QEMU_VSOCK_ID=vhost-vsock-pci0
-MANAGER_QEMU_VSOCK_GUEST_CID=3
-MANAGER_QEMU_VSOCK_VNC=0
-MANAGER_QEMU_BIN_PATH=qemu-system-x86_64
-MANAGER_QEMU_USE_SUDO=true
-MANAGER_QEMU_ENABLE_SEV=false
-MANAGER_QEMU_ENABLE_SEV_SNP=false
-MANAGER_QEMU_ENABLE_KVM=true
-MANAGER_QEMU_MACHINE=q35
-MANAGER_QEMU_CPU=EPYC
-MANAGER_QEMU_SMP_COUNT=4
-MANAGER_QEMU_SMP_MAXCPUS=16
-MANAGER_QEMU_MEM_ID=ram1
-MANAGER_QEMU_KERNEL_HASH=false
-MANAGER_QEMU_NO_GRAPHIC=true
-MANAGER_QEMU_MONITOR=pty
-MANAGER_QEMU_HOST_FWD_RANGE=6100-6200
@@ -1,13 +0,0 @@
-# Copyright (c) Ultraviolet
-# SPDX-License-Identifier: Apache-2.0
-
-coverage:
-  ignore:
-    - "test/*"
-    - "cmd/**"
-    - "**/mocks/**"
-    - "mocks/**"
-    - "**/*.pb.go"
-    - "**/logging.go"
-    - "**/metrics.go"
-    - "**/tracing.go"
@@ -1,86 +1,58 @@
 module github.com/ultravioletrs/cocos

-go 1.23.0
+go 1.21.6

 require (
-	github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746
-	github.com/caarlos0/env/v11 v11.2.2
-	github.com/cenkalti/backoff/v4 v4.3.0
-	github.com/fatih/color v1.18.0
+	github.com/absmach/magistrala v0.0.0-20240119191055-d95283d31472
+	github.com/caarlos0/env/v7 v7.1.0
+	github.com/cenkalti/backoff/v4 v4.2.1
+	github.com/digitalocean/go-libvirt v0.0.0-20221205150000-2939327a8519
 	github.com/go-kit/kit v0.13.0
 	github.com/gofrs/uuid v4.4.0+incompatible
-	github.com/google/go-sev-guest v0.11.1
+	github.com/google/go-sev-guest v0.10.1
 	github.com/mdlayher/vsock v1.2.1
-	github.com/spf13/cobra v1.8.1
+	github.com/prometheus/client_golang v1.18.0
+	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.9.0
-	github.com/virtee/sev-snp-measure-go v0.0.0-20240530153610-e6e8dc9b6877
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.57.0
-	go.opentelemetry.io/otel/trace v1.32.0
-	golang.org/x/crypto v0.29.0
-	golang.org/x/sync v0.9.0
-	google.golang.org/grpc v1.68.0
-	google.golang.org/protobuf v1.35.2
-)
-
-require (
-	github.com/Microsoft/go-winio v0.6.1 // indirect
-	github.com/containerd/log v0.1.0 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
-	github.com/docker/go-connections v0.5.0 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect
-	go.opentelemetry.io/otel v1.32.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.28.0 // indirect
-	golang.org/x/mod v0.19.0 // indirect
-	golang.org/x/tools v0.23.0 // indirect
-	gotest.tools/v3 v3.5.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1
+	go.opentelemetry.io/otel v1.21.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0
+	go.opentelemetry.io/otel/sdk v1.21.0
+	go.opentelemetry.io/otel/trace v1.21.0
+	golang.org/x/crypto v0.19.0
+	golang.org/x/sync v0.6.0
+	google.golang.org/grpc v1.60.1
+	google.golang.org/protobuf v1.32.0
 )

 require (
+	cloud.google.com/go/compute v1.23.3 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/docker/docker v27.3.1+incompatible
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/go-kit/log v0.2.1 // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/google/go-configfs-tsm v0.2.2 // indirect
-	github.com/google/logger v1.1.1
-	github.com/google/uuid v1.6.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
+	github.com/google/logger v1.1.1 // indirect
+	github.com/google/uuid v1.5.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 // indirect
 	github.com/mdlayher/socket v0.4.1 // indirect
 	github.com/pborman/uuid v1.2.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.52.2 // indirect
-	github.com/prometheus/procfs v0.13.0 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	go.opentelemetry.io/otel/metric v1.32.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
+	github.com/prometheus/client_model v0.5.0 // indirect
+	github.com/prometheus/common v0.45.0 // indirect
+	github.com/prometheus/procfs v0.12.0 // indirect
+	go.opentelemetry.io/otel/metric v1.21.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.0.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/net v0.30.0 // indirect
-	golang.org/x/sys v0.27.0 // indirect
-	golang.org/x/term v0.26.0
-	golang.org/x/text v0.20.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241104194629-dd2ea8efbc28 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	golang.org/x/net v0.20.0 // indirect
+	golang.org/x/sys v0.17.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 // indirect
 )
-
-replace github.com/virtee/sev-snp-measure-go => github.com/sammyoina/sev-snp-measure-go v0.0.0-20241107163739-38915ab517c7
@@ -1,36 +1,31 @@
-github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
-github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
-github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
-github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+cloud.google.com/go v0.110.8 h1:tyNdfIxjzaWctIiLYOTalaLKZ17SI44SKFW26QbOhME=
+cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk=
+cloud.google.com/go/compute v1.23.3/go.mod h1:VCgBUoMnIVIR0CscqQiPJLAG25E3ZRZMzcFZeQ+h8CI=
+cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
+cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
 github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
-github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746 h1:Tj567KeGVygjTsSCxn4++skKiz9GkPugM1KMdIFxvfw=
-github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746/go.mod h1:CIx3OsPFc4doJZmBWSA6LNWefcznKv9c3cLOxNxL4q4=
+github.com/absmach/magistrala v0.0.0-20240119191055-d95283d31472 h1:MdS3yTTJP/OSFkMJ4+cJ0LnRS9OyPtPxsR0mSFYglXw=
+github.com/absmach/magistrala v0.0.0-20240119191055-d95283d31472/go.mod h1:02Ip3Ow7JlPT4nb2TdZcOuf7C3ac8tzyEVwB+H1G40g=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/caarlos0/env/v11 v11.2.2 h1:95fApNrUyueipoZN/EhA8mMxiNxrBwDa+oAZrMWl3Kg=
-github.com/caarlos0/env/v11 v11.2.2/go.mod h1:JBfcdeQiBoI3Zh1QRAWfe+tpiNTmDtcCj/hHHHMx0vc=
-github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
-github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
-github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/caarlos0/env/v7 v7.1.0 h1:9lzTF5amyQeWHZzuZeKlCb5FWSUxpG1js43mhbY8ozg=
+github.com/caarlos0/env/v7 v7.1.0/go.mod h1:LPPWniDUq4JaO6Q41vtlyikhMknqymCLBw0eX4dcH1E=
+github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
+github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4 h1:/inchEIKaYC1Akx+H+gqO04wryn5h75LSazbRlnya1k=
+github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
-github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
-github.com/docker/docker v27.3.1+incompatible h1:KttF0XoteNTicmUtBO0L2tP+J7FGRFTjaEF4k6WdhfI=
-github.com/docker/docker v27.3.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
-github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
-github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
-github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
-github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/digitalocean/go-libvirt v0.0.0-20221205150000-2939327a8519 h1:OpkN/n40cmKenDQS+IOAeW9DLhYy4DADSeZnouCEV/E=
+github.com/digitalocean/go-libvirt v0.0.0-20221205150000-2939327a8519/go.mod h1:WyJJyfmJ0gWJvjV+ZH4DOgtOYZc1KOvYyBXWCLKxsUU=
+github.com/envoyproxy/protoc-gen-validate v1.0.2 h1:QkIBuU5k+x7/QXPvPPnWXWlCdaBFApVqftFV6k087DA=
+github.com/envoyproxy/protoc-gen-validate v1.0.2/go.mod h1:GpiZQP3dDbg4JouG/NNS7QWXpgx6x8QiMKdmN72jogE=
 github.com/go-kit/kit v0.13.0 h1:OoneCcHKHQ03LfBpoQCUfCluwd2Vt3ohz+kvbJneZAU=
 github.com/go-kit/kit v0.13.0/go.mod h1:phqEHMMUbyrCFCTgH48JueqrM3md2HcAZ8N3XE4FKDg=
 github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
@@ -38,165 +33,135 @@ github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBj
 github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
 github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
 github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
-github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-configfs-tsm v0.2.2 h1:YnJ9rXIOj5BYD7/0DNnzs8AOp7UcvjfTvt215EWcs98=
 github.com/google/go-configfs-tsm v0.2.2/go.mod h1:EL1GTDFMb5PZQWDviGfZV9n87WeGTR/JUg13RfwkgRo=
-github.com/google/go-sev-guest v0.11.1 h1:gnww4U8fHV5DCPz4gykr1s8SEX1fFNcxCBy+vvXN24k=
-github.com/google/go-sev-guest v0.11.1/go.mod h1:qBOfb+JmgsUI3aUyzQoGC13Kpp9zwLeWvuyXmA9q77w=
+github.com/google/go-sev-guest v0.10.1 h1:kZIcGD513eqInbezqxchTtOLJlVXALyWlIXu5E0tNJE=
+github.com/google/go-sev-guest v0.10.1/go.mod h1:/5hrgGWqG7+MPTXKhQz+v9ZE+Eh4MCBdItCNwgshlrk=
 github.com/google/logger v1.1.1 h1:+6Z2geNxc9G+4D4oDO9njjjn2d0wN5d7uOo0vOIW1NQ=
 github.com/google/logger v1.1.1/go.mod h1:BkeJZ+1FhQ+/d087r4dzojEg1u2ZX+ZqG1jTUrLM+zQ=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 h1:bkypFPDjIYGfCYD5mRBvpqxfYX1YCS1PXdKYWi8FsN0=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0/go.mod h1:P+Lt/0by1T8bfcF3z737NnSbmxQAppXMRziHUxPOC8k=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 h1:Wqo399gCIufwto+VfwCSvsnfGpF/w5E9CNxSwbpD6No=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0/go.mod h1:qmOFXW2epJhM0qSnUUYpldc7gVz2KMQwJ/QYCDIa7XU=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 h1:jWpvCLoY8Z/e3VKvlsiIGKtc+UG6U5vzxaoagmhXfyg=
+github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0/go.mod h1:QUyp042oQthUoa9bqDv0ER0wrtXnBruoNd7aNjkbP+k=
 github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U=
 github.com/mdlayher/socket v0.4.1/go.mod h1:cAqeGjoufqdxWkD7DkpyS+wcefOtmu5OQ8KuoJGIReA=
 github.com/mdlayher/vsock v1.2.1 h1:pC1mTJTvjo1r9n9fbm7S1j04rCgCzhCOS5DY0zqHlnQ=
 github.com/mdlayher/vsock v1.2.1/go.mod h1:NRfCibel++DgeMD8z/hP+PPTjlNJsdPOmxcnENvE+SE=
-github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
-github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
-github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
-github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
-github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
-github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
-github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
-github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
-github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
-github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
 github.com/pborman/uuid v1.2.1 h1:+ZZIw58t/ozdjRaXh/3awHfmWRbzYxJoAdNJxe/3pvw=
 github.com/pborman/uuid v1.2.1/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.52.2 h1:LW8Vk7BccEdONfrJBDffQGRtpSzi5CQaRZGtboOO2ck=
-github.com/prometheus/common v0.52.2/go.mod h1:lrWtQx+iDfn2mbH5GUzlH9TSHyfZpHkSiG1W7y3sF2Q=
-github.com/prometheus/procfs v0.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
-github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk=
+github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA=
+github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
+github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
+github.com/prometheus/common v0.45.0 h1:2BGz0eBc2hdMDLnO/8n0jeB3oPrt2D08CekT0lneoxM=
+github.com/prometheus/common v0.45.0/go.mod h1:YJmSTw9BoKxJplESWWxlbyttQR4uaEcGyv9MZjVOJsY=
+github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
+github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sammyoina/sev-snp-measure-go v0.0.0-20241107163739-38915ab517c7 h1:g+a3hLU4pl41mhP+CQu3+bDhL4HSfrnPI1BvLjKfD8Y=
-github.com/sammyoina/sev-snp-measure-go v0.0.0-20241107163739-38915ab517c7/go.mod h1:dEkBe8JnxU5itNjZDEQINFd7f7l4DtjfqRuzPQcit4w=
-github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
-github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.57.0 h1:qtFISDHKolvIxzSs0gIaiPUPR0Cucb0F2coHC7ZLdps=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.57.0/go.mod h1:Y+Pop1Q6hCOnETWTW4NROK/q1hv50hM7yDaUTjG8lp8=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXefpVJtvA/8srF4V4y0akAoPHkIslgAkjixJA=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg=
-go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U=
-go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0 h1:j9+03ymgYhPKmeXGk5Zu+cIZOlVzd9Zv7QIiyItjFBU=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.28.0/go.mod h1:Y5+XiUG4Emn1hTfciPzGPJaSI+RpDts6BnCIir0SLqk=
-go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M=
-go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8=
-go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE=
-go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg=
-go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM=
-go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8=
-go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
-go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1 h1:SpGay3w+nEwMpfVnbqOLH5gY52/foP8RE8UzTZ1pdSE=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1/go.mod h1:4UoMYEZOC0yN/sPGH76KPkkU7zgiEWYWL9vwmbnTJPE=
+go.opentelemetry.io/otel v1.21.0 h1:hzLeKBZEL7Okw2mGzZ0cc4k/A7Fta0uoPgaJCr8fsFc=
+go.opentelemetry.io/otel v1.21.0/go.mod h1:QZzNPQPm1zLX4gZK4cMi+71eaorMSGT3A4znnUvNNEo=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 h1:cl5P5/GIfFh4t6xyruOgJP5QiA1pw4fYYdv6nc6CBWw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0/go.mod h1:zgBdWWAu7oEEMC06MMKc5NLbA/1YDXV1sMpSqEeLQLg=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0 h1:digkEZCJWobwBqMwC0cwCq8/wkkRy/OowZg5OArWZrM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.21.0/go.mod h1:/OpE/y70qVkndM0TrxT4KBoN3RsFZP0QaofcfYrj76I=
+go.opentelemetry.io/otel/metric v1.21.0 h1:tlYWfeo+Bocx5kLEloTjbcDwBuELRrIFxwdQ36PlJu4=
+go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM=
+go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8=
+go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
+go.opentelemetry.io/otel/trace v1.21.0 h1:WD9i5gzvoUPuXIXH24ZNBudiarZDKuekPqi/E8fpfLc=
+go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ=
+go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I=
+go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8=
-golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
-golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/oauth2 v0.15.0 h1:s8pnnxNVzjWyrvYdFUQq5llS1PX2zhPXmccZv99h7uQ=
+golang.org/x/oauth2 v0.15.0/go.mod h1:q48ptWNTY5XWf+JNten23lcvHpLJ0ZSxF5ttTHKVCAM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
-golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU=
-golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
-golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
-golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
-golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg=
-golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 h1:hjSy6tcFQZ171igDaN5QHOw2n6vx40juYbC/x67CEhc=
-google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:qpvKtACPCQhAdu3PyQgV4l3LMXZEtft7y8QcarRsp9I=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241104194629-dd2ea8efbc28 h1:XVhgTWWV3kGQlwJHR3upFWZeTsei6Oks1apkZSeonIE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241104194629-dd2ea8efbc28/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
-google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0=
-google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA=
-google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io=
-google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
+google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
+google.golang.org/genproto v0.0.0-20240102182953-50ed04b92917 h1:nz5NESFLZbJGPFxDT/HCn+V1mZ8JGNoY4nUpmW/Y2eg=
+google.golang.org/genproto v0.0.0-20240102182953-50ed04b92917/go.mod h1:pZqR+glSb11aJ+JQcczCvgf47+duRuzNSKqE8YAQnV0=
+google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 h1:OPXtXn7fNMaXwO3JvOmF1QyTc00jsSFFz1vXXBOdCDo=
+google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:B5xPO//w8qmBDjGReYLpR6UJPnkldGkCSMoH/2vxJeg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 h1:gphdwh0npgs8elJ4T6J+DQJHPVF7RsuJHCfwztUb4J4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:daQN87bsDqDoe316QbbvX60nMoJQa4r6Ds0ZuoAe5yA=
+google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU=
+google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
-gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
@@ -1,2 +1 @@
-source "$BR2_EXTERNAL_COCOS_PATH/package/agent/Config.in"
-source "$BR2_EXTERNAL_COCOS_PATH/package/wasmedge/Config.in"
+source "$BR2_EXTERNAL_COCOS_PATH/package/agent/Config.in"
@@ -1,16 +1,13 @@
 # Hardware Abstraction Layer (HAL) for Confidential Computing
-
-Cocos HAL for Linux is framework for building custom in-enclave Linux distribution.
+Cocos HAL for Linux is framework for building custom in-enclave Linux distribution. 

 ## Usage
-
 HAL uses [Buildroot](https://buildroot.org/)'s [_External Tree_ mechanism](https://buildroot.org/downloads/manual/manual.html#outside-br-custom) for building custom distro:

 ```bash
 git clone git@github.com:ultravioletrs/cocos.git
 git clone git@github.com:buildroot/buildroot.git
 cd buildroot
-git checkout 2024.11-rc2
 make BR2_EXTERNAL=../cocos/hal/linux cocos_defconfig
 # Execute 'make menuconfig' only if you want to make additional configuration changes to Buildroot.
 make menuconfig
@@ -40,9 +40,6 @@ CONFIG_TMPFS_POSIX_ACL=y
 CONFIG_UNWINDER_FRAME_POINTER=y
 CONFIG_VSOCKETS=y
 CONFIG_VIRTIO_VSOCKETS=y
-CONFIG_NF_TABLES=y
-CONFIG_BPF_SYSCALL=y
-CONFIG_CGROUP_BPF=y

 ###
 # AMD SEV-SNP
@@ -64,4 +61,4 @@ CONFIG_PREEMPT=n
 CONFIG_PREEMPT_DYNAMIC=n
 CONFIG_DEBUG_PREEMPT=n
 CONFIG_CGROUP_MISC=y
-CONFIG_X86_CPUID=y
+CONFIG_X86_CPUID=y
@@ -7,7 +7,6 @@ BR2_TARGET_GENERIC_ISSUE="Welcome to Cocos"
 BR2_PACKAGE_DHCP=y
 BR2_PACKAGE_DHCP_CLIENT=y
 BR2_INIT_SYSTEMD=y
-BR2_SYSTEM_BIN_SH_BASH=y

 # Filesystem
 # BR2_TARGET_ROOTFS_TAR is not set
@@ -23,16 +22,18 @@ BR2_ROOTFS_POST_IMAGE_SCRIPT="$(BR2_EXTERNAL_COCOS_PATH)/board/cocos/post-image.
 BR2_ROOTFS_POST_SCRIPT_ARGS="$(BR2_DEFCONFIG)"

 # Linux headers same as kernel
-BR2_PACKAGE_HOST_LINUX_HEADERS_CUSTOM_6_11=y
+BR2_PACKAGE_HOST_LINUX_HEADERS_CUSTOM_6_6=y
+BR2_TOOLCHAIN_HEADERS_AT_LEAST_6_5=y
+BR2_TOOLCHAIN_HEADERS_AT_LEAST_6_6=y
 BR2_TOOLCHAIN_HEADERS_LATEST=y
-BR2_TOOLCHAIN_HEADERS_AT_LEAST="6.12-rc6"
+BR2_TOOLCHAIN_HEADERS_AT_LEAST="6.6"

 # Kernel
 BR2_LINUX_KERNEL=y
 BR2_LINUX_KERNEL_CUSTOM_GIT=y
 BR2_LINUX_KERNEL_CUSTOM_REPO_URL="https://github.com/torvalds/linux.git"
-BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="v6.12-rc6"
-BR2_LINUX_KERNEL_VERSION="v6.12-rc6"
+BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="v6.6"
+BR2_LINUX_KERNEL_VERSION="v6.6"
 BR2_LINUX_KERNEL_PATCH=""
 BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
 BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="$(BR2_EXTERNAL_COCOS_PATH)/board/cocos/linux.config"
@@ -42,30 +43,6 @@ BR2_LINUX_KERNEL_NEEDS_HOST_LIBELF=y
 BR2_PACKAGE_HOST_QEMU=y
 BR2_PACKAGE_HOST_QEMU_SYSTEM_MODE=y

-# Docker
-BR2_PACKAGE_LIBSECCOMP_ARCH_SUPPORTS=y
-BR2_PACKAGE_LIBSECCOMP=y
-BR2_PACKAGE_CA_CERTIFICATES=y
-BR2_PACKAGE_DOCKER_CLI=y
-BR2_PACKAGE_DOCKER_COMPOSE=y
-BR2_PACKAGE_DOCKER_ENGINE=y
-BR2_PACKAGE_CONTAINERD=y
-BR2_PACKAGE_RUNC=y
-BR2_PACKAGE_IPTABLES=y
-
 # Python
 BR2_PACKAGE_PYTHON3=y
 BR2_PACKAGE_PYTHON_PIP=y
-BR2_PACKAGE_BZIP2=y
-BR2_PACKAGE_XZ=y
-BR2_PACKAGE_ZIP=y
-BR2_PACKAGE_PYTHON3_ZLIB=y
-BR2_PACKAGE_PYTHON3_XZ=y
-BR2_PACKAGE_PYTHON3_BZIP2=y
-BR2_INSTALL_LIBSTDCPP=y
-BR2_TOOLCHAIN_BUILDROOT_CXX=y
-BR2_PACKAGE_HOST_GCC_TARGET=y
-BR2_TOOLCHAIN_BUILDROOT_LIBSTDCPP=y
-BR2_PACKAGE_GCC=y
-BR2_PACKAGE_GCC_TARGET=y
-BR2_PACKAGE_LIBSTDCPP=y
@@ -1 +1 @@
-include $(sort $(wildcard $(BR2_EXTERNAL_COCOS_PATH)/package/*/*.mk))
+include $(sort $(wildcard $(BR2_EXTERNAL_COCOS_PATH)/package/*/*.mk))
--- a/Show More
+++ b/Show More