acp-plugin-gamesdk 0.1.24__py3-none-any.whl → 0.1.26__py3-none-any.whl

acp_plugin_gamesdk/acp_plugin.py

@@ -1,54 +1,32 @@
 import json
-import signal
-import sys
 import traceback
-from collections.abc import Callable
-from dataclasses import asdict, dataclass
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional, Tuple
+from dataclasses import dataclass
+from datetime import datetime, timezone, timedelta
+from typing import List, Dict, Any, Optional,Tuple
 
-import socketio
+import requests
 
 from game_sdk.game.agent import WorkerConfig
 from game_sdk.game.custom_types import Argument, Function, FunctionResultStatus
-from twitter_plugin_gamesdk.game_twitter_plugin import GameTwitterPlugin
 from twitter_plugin_gamesdk.twitter_plugin import TwitterPlugin
-from acp_plugin_gamesdk.acp_client import AcpClient
-from acp_plugin_gamesdk.acp_token import AcpToken
-from acp_plugin_gamesdk.interface import (
-    AcpJob,
-    AcpJobPhasesDesc,
-    IDeliverable,
-    IInventory,
-)
 
+from acp_plugin_gamesdk.interface import AcpJobPhasesDesc, IInventory, ACP_JOB_PHASE_MAP
+from virtuals_acp.client import VirtualsACP 
+from virtuals_acp.job import ACPJob
 
 @dataclass
 class AcpPluginOptions:
     api_key: str
-    acp_token_client: AcpToken
-    twitter_plugin: TwitterPlugin | GameTwitterPlugin = None
+    acp_client: VirtualsACP  
+    twitter_plugin: TwitterPlugin | None = None
     cluster: Optional[str] = None
     evaluator_cluster: Optional[str] = None
-    on_evaluate: Optional[Callable[[IDeliverable], Tuple[bool, str]]] = None
-    on_phase_change: Optional[Callable[[AcpJob], None]] = None
     job_expiry_duration_mins: Optional[int] = None
-
-
-SocketEvents = {
-    "JOIN_EVALUATOR_ROOM": "joinEvaluatorRoom",
-    "LEAVE_EVALUATOR_ROOM": "leaveEvaluatorRoom",
-    "ON_EVALUATE": "onEvaluate",
-    "ROOM_JOINED": "roomJoined",
-    "ON_PHASE_CHANGE": "onPhaseChange"
-}
-
-
+    
 class AcpPlugin:
     def __init__(self, options: AcpPluginOptions):
         print("Initializing AcpPlugin")
-        self.acp_token_client = options.acp_token_client
-        self.acp_client = AcpClient(options.api_key, options.acp_token_client)
+        self.acp_client = options.acp_client
         self.id = "acp_worker"
         self.name = "ACP Worker"
         self.description = """
@@ -71,97 +49,85 @@ class AcpPlugin:
         self.twitter_plugin = None
         if options.twitter_plugin is not None:
             self.twitter_plugin = options.twitter_plugin
-
+            
         self.produced_inventory: List[IInventory] = []
-        self.acp_base_url = self.acp_token_client.acp_base_url
-        if options.on_evaluate is not None or options.on_phase_change is not None:
-            print("Initializing socket")
-            self.socket = None
-            if options.on_evaluate is not None:
-                self.on_evaluate = options.on_evaluate
-            if options.on_phase_change is not None:
-                def phase_change_wrapper(job: AcpJob):
-                    job["getAgentByWalletAddress"] = self.acp_client.get_agent_by_wallet_address
-                    return options.on_phase_change(job)
-
-                self.on_phase_change = phase_change_wrapper
-            self.initialize_socket()
+        self.acp_base_url = self.acp_client.acp_api_url
         self.job_expiry_duration_mins = options.job_expiry_duration_mins if options.job_expiry_duration_mins is not None else 1440
-
-    def initialize_socket(self) -> Tuple[bool, str]:
-        """
-        Initialize socket connection for real-time communication.
-        Returns a tuple of (success, message).
-        """
-        try:
-            self.socket = socketio.Client()
-
-            # Set up authentication before connecting
-            self.socket.auth = {
-                "evaluatorAddress": self.acp_token_client.agent_wallet_address
-            }
-
-            # Connect socket to GAME SDK dev server
-            self.socket.connect(self.acp_client.base_url, auth=self.socket.auth)
-
-            if self.socket.connected:
-                self.socket.emit(SocketEvents["JOIN_EVALUATOR_ROOM"], self.acp_token_client.agent_wallet_address)
-
-            # Set up event handler for evaluation requests
-            @self.socket.on(SocketEvents["ON_EVALUATE"])
-            def on_evaluate(data):
-                if self.on_evaluate:
-                    deliverable = data.get("deliverable")
-                    memo_id = data.get("memoId")
-
-                    is_approved, reasoning = self.on_evaluate(deliverable)
-
-                    self.acp_token_client.sign_memo(memo_id, is_approved, reasoning)
-
-                    # Set up event handler for phase changes
-
-            @self.socket.on(SocketEvents["ON_PHASE_CHANGE"])
-            def on_phase_change(data):
-                if hasattr(self, 'on_phase_change') and self.on_phase_change:
-                    self.on_phase_change(data)
-
-            # Set up cleanup function for graceful shutdown
-            def cleanup():
-                if self.socket:
-                    print("Disconnecting socket")
-                    import time
-                    time.sleep(1)
-                    self.socket.disconnect()
-
-            def signal_handler(_sig, _frame):
-                cleanup()
-                sys.exit(0)
-
-            signal.signal(signal.SIGINT, signal_handler)
-            signal.signal(signal.SIGTERM, signal_handler)
-
-            return True, "Socket initialized successfully"
-
-        except Exception as e:
-            return False, f"Failed to initialize socket: {str(e)}"
-
-    def set_on_phase_change(self, on_phase_change: Callable[[AcpJob], None]) -> None:
-        self.on_phase_change = on_phase_change
-
+        
     def add_produce_item(self, item: IInventory) -> None:
         self.produced_inventory.append(item)
-
-    def reset_state(self) -> None:
-        self.acp_client.reset_state()
-
-    def delete_completed_job(self, job_id: int) -> None:
-        self.acp_client.delete_completed_job(job_id)
+    
+    def memo_to_dict(self, m):
+        return {
+            "id": m.id,
+            "type": m.type.name,
+            "content": m.content,
+            "next_phase": m.next_phase.name
+        }
+
+    def _to_state_acp_job(self, job: ACPJob) -> Dict:
+        memos = []
+        for memo in job.memos:
+            memos.append(self.memo_to_dict(memo))
+            
+        
+        return {
+            "jobId": job.id,
+            "clientName":  job.client_agent.name if job.client_agent else "",
+            "providerName": job.provider_agent.name if job.provider_agent else "",
+            "desc": job.service_requirement or "",
+            "price": str(job.price),
+            "providerAddress": job.provider_address,
+            "phase": ACP_JOB_PHASE_MAP.get(job.phase),
+            "memo": list(reversed(memos)),
+            "tweetHistory": [
+                {
+                    "type": tweet.get("type"),
+                    "tweet_id": tweet.get("tweetId"),
+                    "content": tweet.get("content"),
+                    "created_at": tweet.get("createdAt")
+                }
+                for tweet in reversed(job.context.get('tweets', []) if job.context else [])
+            ],
+        }
 
     def get_acp_state(self) -> Dict:
-        server_state = self.acp_client.get_state()
-        server_state.inventory.produced = self.produced_inventory
-        state = asdict(server_state)
-        return state
+        active_jobs = self.acp_client.get_active_jobs()
+        completed_jobs = self.acp_client.get_completed_jobs()
+        cancelled_jobs = self.acp_client.get_cancelled_jobs()
+
+        agent_addr = self.acp_client.agent_address.lower()
+
+        active_buyer_jobs = []
+        active_seller_jobs = []
+        
+        for job in active_jobs:
+            processed = self._to_state_acp_job(job)
+            client_addr = job.client_address.lower()
+            provider_addr = job.provider_address.lower()
+            
+            if client_addr == agent_addr:
+                active_buyer_jobs.append(processed)
+            if provider_addr == agent_addr:
+                active_seller_jobs.append(processed)
+
+        completed = [self._to_state_acp_job(job) for job in completed_jobs]
+        cancelled = [self._to_state_acp_job(job) for job in cancelled_jobs]
+        
+        return {
+            "inventory": {
+                "acquired": [],
+                "produced": [item.model_dump() for item in self.produced_inventory] if self.produced_inventory else [],
+            },
+            "jobs": {
+                "active": {
+                    "asABuyer": active_buyer_jobs,
+                    "asASeller": active_seller_jobs,
+                },
+                "completed": completed,
+                "cancelled": cancelled,
+            }
+        }
 
     def get_worker(self, data: Optional[Dict] = None) -> WorkerConfig:
         functions = data.get("functions") if data else [
@@ -171,7 +137,7 @@ class AcpPlugin:
             self.pay_job,
             self.deliver_job,
         ]
-
+        
         def get_environment(_function_result, _current_state) -> Dict[str, Any]:
             environment = data.get_environment() if hasattr(data, "get_environment") else {}
             return {
@@ -186,7 +152,7 @@ class AcpPlugin:
             get_state_fn=get_environment,
             instruction=data.get("instructions") if data else None
         )
-
+        
         return worker_config
 
     @property
@@ -205,12 +171,12 @@ class AcpPlugin:
           - Each job tracks:
             * phase: request (seller should response to accept/reject to the job) → pending_payment (as a buyer to make the payment for the service) → in_progress (seller to deliver the service) → evaluation → completed/rejected
         """
-
+        
     def _search_agents_executable(self, reasoning: str, keyword: str) -> Tuple[FunctionResultStatus, str, dict]:
         if not reasoning:
             return FunctionResultStatus.FAILED, "Reasoning for the search must be provided. This helps track your decision-making process for future reference.", {}
 
-        agents = self.acp_client.browse_agents(self.cluster, keyword, rerank=True, top_k=1)
+        agents = self.acp_client.browse_agents(keyword, self.cluster)
 
         if not agents:
             return FunctionResultStatus.FAILED, "No other trading agents found in the system. Please try again later when more agents are available.", {}
@@ -228,7 +194,7 @@ class AcpPlugin:
                             "wallet_address": agent.wallet_address,
                             "offerings": (
                                 [
-                                    {"name": offering.name, "price": offering.price}
+                                    {"name": offering.type, "price": offering.price}
                                     for offering in agent.offerings
                                 ]
                                 if agent.offerings
@@ -239,7 +205,7 @@ class AcpPlugin:
                     ],
                     "totalAgentsFound": len(agents),
                     "timestamp": datetime.now().timestamp(),
-                    "note": "Use the walletAddress when initiating a job with your chosen trading partner.",
+                    "note": "Use the wallet_address when initiating a job with your chosen trading partner.",
                 }
             ),
             {},
@@ -291,22 +257,21 @@ class AcpPlugin:
             type="string",
             description="Detailed specifications for service-based items",
         )
-
+        
         require_evaluation_arg = Argument(
             name="require_evaluation",
             type="boolean",
             description="Decide if your job request is complex enough to spend money for evaluator agent to assess the relevancy of the output. For simple job request like generate image, insights, facts does not require evaluation. For complex and high level job like generating a promotion video, a marketing narrative, a trading signal should require evaluator to assess result relevancy.",
         )
-
+        
         evaluator_keyword_arg = Argument(
             name="evaluator_keyword",
             type="string",
             description="Keyword to search for a evaluator",
         )
 
-        args = [seller_wallet_address_arg, price_arg, reasoning_arg, service_requirements_arg, require_evaluation_arg,
-                evaluator_keyword_arg]
-
+        args = [seller_wallet_address_arg, price_arg, reasoning_arg, service_requirements_arg, require_evaluation_arg, evaluator_keyword_arg]
+        
         if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None:
             tweet_content_arg = Argument(
                 name="tweet_content",
@@ -314,7 +279,7 @@ class AcpPlugin:
                 description="Tweet content that will be posted about this job. Must include the seller's Twitter handle (with @ symbol) to notify them",
             )
             args.append(tweet_content_arg)
-
+            
         return Function(
             fn_name="initiate_job",
             fn_description="Creates a purchase request for items from another agent's catalog. Only for use when YOU are the buyer. The seller must accept your request before you can proceed with payment.",
@@ -322,9 +287,7 @@ class AcpPlugin:
             executable=self._initiate_job_executable
         )
 
-    def _initiate_job_executable(self, seller_wallet_address: str, price: str, reasoning: str,
-                                 service_requirements: str, require_evaluation: str, evaluator_keyword: str,
-                                 tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
+    def _initiate_job_executable(self, seller_wallet_address: str, price: str, reasoning: str, service_requirements: str, require_evaluation: str, evaluator_keyword: str, tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
         if isinstance(require_evaluation, str):
             require_evaluation = require_evaluation.lower() == 'true'
         elif isinstance(require_evaluation, bool):
@@ -334,55 +297,38 @@ class AcpPlugin:
 
         if not price:
             return FunctionResultStatus.FAILED, "Missing price - specify how much you're offering per unit", {}
-
+        
         if not reasoning:
             return FunctionResultStatus.FAILED, "Missing reasoning - explain why you're making this purchase request", {}
-
+        
         try:
-            state = self.get_acp_state()
-
-            existing_job = next(
-                (job for job in state["jobs"]["active"]["asABuyer"]
-                 if job["providerAddress"] == seller_wallet_address),
-                None
-            )
-
-            if existing_job:
-                return FunctionResultStatus.FAILED, f"You already have an active job as a buyer with {existing_job['providerAddress']} - complete the current job before initiating a new one", {}
-
             if not seller_wallet_address:
                 return FunctionResultStatus.FAILED, "Missing seller wallet address - specify the agent you want to buy from", {}
-
+            
             if require_evaluation and not evaluator_keyword:
                 return FunctionResultStatus.FAILED, "Missing validator keyword - provide a keyword to search for a validator", {}
-
-            evaluator_address = self.acp_token_client.get_agent_wallet_address()
-
+            
+            evaluator_address = self.acp_client.agent_address
+            
             if require_evaluation:
-                validators = self.acp_client.browse_agents(self.evaluator_cluster, evaluator_keyword, rerank=True,
-                                                           top_k=1)
-
+                validators = self.acp_client.browse_agents(evaluator_keyword, self.evaluator_cluster)
+                
                 if len(validators) == 0:
                     return FunctionResultStatus.FAILED, "No evaluator found - try a different keyword", {}
 
                 evaluator_address = validators[0].wallet_address
-
-            # ... Rest of validation logic ...
+            
             expired_at = datetime.now(timezone.utc) + timedelta(minutes=self.job_expiry_duration_mins)
-            job_id = self.acp_client.create_job(
+            job_id = self.acp_client.initiate_job(
                 seller_wallet_address,
-                float(price),
                 service_requirements,
+                float(price),
                 evaluator_address,
                 expired_at
             )
 
             if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None and tweet_content is not None:
-                post_tweet_fn = self.twitter_plugin.get_function('post_tweet')
-                tweet_id = post_tweet_fn(tweet_content).get('data', {}).get('id')
-                if tweet_id is not None:
-                    self.acp_client.add_tweet(job_id, tweet_id, tweet_content)
-                    print("Tweet has been posted")
+                self._tweet_job(job_id, f"{tweet_content} #{job_id}")
 
             return FunctionResultStatus.DONE, json.dumps({
                 "jobId": job_id,
@@ -414,9 +360,9 @@ class AcpPlugin:
             type="string",
             description="Why you made this decision",
         )
-
+        
         args = [job_id_arg, decision_arg, reasoning_arg]
-
+        
         if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None:
             tweet_content_arg = Argument(
                 name="tweet_content",
@@ -432,20 +378,19 @@ class AcpPlugin:
             executable=self._respond_job_executable
         )
 
-    def _respond_job_executable(self, job_id: int, decision: str, reasoning: str,
-                                tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
+    def _respond_job_executable(self, job_id: int, decision: str, reasoning: str, tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
         if not job_id:
             return FunctionResultStatus.FAILED, "Missing job ID - specify which job you're responding to", {}
-
+        
         if not decision or decision not in ["ACCEPT", "REJECT"]:
             return FunctionResultStatus.FAILED, "Invalid decision - must be either 'ACCEPT' or 'REJECT'", {}
-
+            
         if not reasoning:
             return FunctionResultStatus.FAILED, "Missing reasoning - explain why you made this decision", {}
 
         try:
             state = self.get_acp_state()
-
+            
             job = next(
                 (c for c in state["jobs"]["active"]["asASeller"] if c["jobId"] == job_id),
                 None
@@ -457,14 +402,17 @@ class AcpPlugin:
             if job["phase"] != AcpJobPhasesDesc.REQUEST:
                 return FunctionResultStatus.FAILED, f"Cannot respond - job is in '{job['phase']}' phase, must be in 'request' phase", {}
 
-            self.acp_client.response_job(
+            self.acp_client.respond_to_job_memo(
                 job_id,
-                decision == "ACCEPT",
                 job["memo"][0]["id"],
+                decision == "ACCEPT",
                 reasoning
             )
 
-            self._reply_tweet(job, tweet_content)
+            if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None and tweet_content is not None:
+                tweet_id = job.get("tweetHistory", [])[0].get("tweet_id") if job.get("tweetHistory") else None
+                if tweet_id:
+                    self._tweet_job(job_id, tweet_content, tweet_id)
 
             return FunctionResultStatus.DONE, json.dumps({
                 "jobId": job_id,
@@ -495,7 +443,7 @@ class AcpPlugin:
         )
 
         args = [job_id_arg, amount_arg, reasoning_arg]
-
+        
         if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None:
             tweet_content_arg = Argument(
                 name="tweet_content",
@@ -511,8 +459,7 @@ class AcpPlugin:
             executable=self._pay_job_executable
         )
 
-    def _pay_job_executable(self, job_id: int, amount: float, reasoning: str, tweet_content: Optional[str] = None) -> \
-            Tuple[FunctionResultStatus, str, dict]:
+    def _pay_job_executable(self, job_id: int, amount: float, reasoning: str, tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
         if not job_id:
             return FunctionResultStatus.FAILED, "Missing job ID - specify which job you're paying for", {}
 
@@ -524,7 +471,7 @@ class AcpPlugin:
 
         try:
             state = self.get_acp_state()
-
+            
             job = next(
                 (c for c in state["jobs"]["active"]["asABuyer"] if c["jobId"] == job_id),
                 None
@@ -536,14 +483,18 @@ class AcpPlugin:
             if job["phase"] != AcpJobPhasesDesc.NEGOTIATION:
                 return FunctionResultStatus.FAILED, f"Cannot pay - job is in '{job['phase']}' phase, must be in 'negotiation' phase", {}
 
-            self.acp_client.make_payment(
+
+            self.acp_client.pay_for_job(
                 job_id,
-                amount,
                 job["memo"][0]["id"],
+                amount,
                 reasoning
             )
 
-            self._reply_tweet(job, tweet_content)
+            if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None and tweet_content is not None:
+                tweet_id = job.get("tweetHistory", [])[0].get("tweet_id") if job.get("tweetHistory") else None
+                if tweet_id:
+                    self._tweet_job(job_id, tweet_content, tweet_id)
 
             return FunctionResultStatus.DONE, json.dumps({
                 "jobId": job_id,
@@ -575,7 +526,7 @@ class AcpPlugin:
         )
 
         args = [job_id_arg, deliverable_arg, reasoning_arg]
-
+        
         if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None:
             tweet_content_arg = Argument(
                 name="tweet_content",
@@ -591,20 +542,19 @@ class AcpPlugin:
             executable=self._deliver_job_executable
         )
 
-    def _deliver_job_executable(self, job_id: int, deliverable: str, reasoning: str,
-                                tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
+    def _deliver_job_executable(self, job_id: int, deliverable: str, reasoning: str, tweet_content: Optional[str] = None) -> Tuple[FunctionResultStatus, str, dict]:
         if not job_id:
             return FunctionResultStatus.FAILED, "Missing job ID - specify which job you're delivering for", {}
-
+            
         if not reasoning:
             return FunctionResultStatus.FAILED, "Missing reasoning - explain why you're making this delivery", {}
-
+            
         if not deliverable:
             return FunctionResultStatus.FAILED, "Missing deliverable - specify what you're delivering", {}
 
         try:
             state = self.get_acp_state()
-
+            
             job = next(
                 (c for c in state["jobs"]["active"]["asASeller"] if c["jobId"] == job_id),
                 None
@@ -617,42 +567,84 @@ class AcpPlugin:
                 return FunctionResultStatus.FAILED, f"Cannot deliver - job is in '{job['phase']}' phase, must be in 'transaction' phase", {}
 
             produced = next(
-                (i for i in self.produced_inventory if
-                 (i["jobId"] if isinstance(i, dict) else i.jobId) == job["jobId"]),
+                (i for i in self.produced_inventory if (i["jobId"] if isinstance(i, dict) else i.jobId) == job["jobId"]),
                 None
             )
 
             if not produced:
                 return FunctionResultStatus.FAILED, "Cannot deliver - you should be producing the deliverable first before delivering it", {}
 
-            deliverable: dict = {
+            _deliverable: dict = {
                 "type": produced.type,
                 "value": produced.value
             }
 
-            self.acp_client.deliver_job(
+            self.acp_client.submit_job_deliverable(
                 job_id,
-                json.dumps(deliverable),
+                json.dumps(_deliverable),
             )
 
-            self._reply_tweet(job, tweet_content)
+            if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None and tweet_content is not None:
+                tweet_id = job.get("tweetHistory", [])[0].get("tweet_id") if job.get("tweetHistory") else None
+                if tweet_id:
+                    self._tweet_job(job_id, tweet_content, tweet_id)
+                
             return FunctionResultStatus.DONE, json.dumps({
                 "status": "success",
                 "jobId": job_id,
-                "deliverable": deliverable,
+                "deliverable": _deliverable,
                 "timestamp": datetime.now().timestamp()
             }), {}
         except Exception as e:
             print(traceback.format_exc())
             return FunctionResultStatus.FAILED, f"System error while delivering items - try again after a short delay. {str(e)}", {}
 
-    def _reply_tweet(self, job: dict, tweet_content: str):
-        if hasattr(self, 'twitter_plugin') and self.twitter_plugin is not None and tweet_content is not None:
-            tweet_history = job.get("tweetHistory", [])
-            tweet_id = tweet_history[-1].get("tweetId") if tweet_history else None
-            if tweet_id is not None:
-                reply_tweet_fn = self.twitter_plugin.get_function('reply_tweet')
-                tweet_id = reply_tweet_fn(tweet_id, tweet_content, None).get('data', {}).get('id')
-                if tweet_id is not None:
-                    self.acp_client.add_tweet(job.get("jobId"), tweet_id, tweet_content)
-                    print("Tweet has been posted")
+    def _tweet_job(self, job_id: int, content: str, tweet_id: Optional[str] = None):
+        if not hasattr(self, 'twitter_plugin') or self.twitter_plugin is None:
+            return
+
+        job = self.acp_client.get_job_by_onchain_id(job_id)
+        if not job:
+            raise Exception("ERROR (tweetJob): Job not found")
+
+              
+        if tweet_id :
+            response = self.twitter_plugin.twitter_client.create_tweet(
+                text=content,
+                in_reply_to_tweet_id=tweet_id
+            )
+        else:
+            response = self.twitter_plugin.twitter_client.create_tweet(text=content)
+
+
+        role = "buyer" if job.client_address.lower() == self.acp_client.agent_address.lower() else "seller"
+
+        # Safely extract tweet ID
+        tweet_id = None
+        if isinstance(response, dict):
+            tweet_id = response.get('data', {}).get('id') or response.get('id')
+        
+        context = {
+            **(job.context or {}),
+            'tweets': [
+                *((job.context or {}).get('tweets', [])),
+                {
+                    'type': role,
+                    'tweetId': tweet_id,
+                    'content': content,
+                    'createdAt': int(datetime.now().timestamp() * 1000)
+                },
+            ],
+        }
+
+        response = requests.patch(
+            f"{self.acp_base_url}/jobs/{job_id}/context",
+            headers={
+                "Content-Type": "application/json",
+                "wallet-address": self.acp_client.agent_address,
+            },
+            json={"data": {"context": context}}
+        )
+
+        if not response.ok:
+            raise Exception(f"ERROR (tweetJob): {response.status_code} {response.text}")

acp_plugin_gamesdk/env.py

@@ -0,0 +1,35 @@
+from typing import Optional
+from virtuals_acp.env import EnvSettings
+from pydantic import field_validator
+
+class PluginEnvSettings(EnvSettings):
+    GAME_DEV_API_KEY: str
+    GAME_API_KEY: str
+    BUYER_AGENT_GAME_TWITTER_ACCESS_TOKEN: str
+    SELLER_AGENT_GAME_TWITTER_ACCESS_TOKEN: str
+    WHITELISTED_WALLET_ENTITY_ID: Optional[int] = None
+    # BUYER_AGENT_TWITTER_BEARER_TOKEN: str
+    # BUYER_AGENT_TWITTER_API_KEY: str
+    # BUYER_AGENT_TWITTER_API_SECRET_KEY: str
+    # BUYER_AGENT_TWITTER_ACCESS_TOKEN: str
+    # BUYER_AGENT_TWITTER_ACCESS_TOKEN_SECRET: str
+    # SELLER_AGENT_TWITTER_BEARER_TOKEN: str
+    # SELLER_AGENT_TWITTER_API_KEY: str
+    # SELLER_AGENT_TWITTER_API_SECRET_KEY: str
+    # SELLER_AGENT_TWITTER_ACCESS_TOKEN: str
+    # SELLER_AGENT_TWITTER_ACCESS_TOKEN_SECRET: str
+
+    @field_validator("GAME_DEV_API_KEY", "GAME_API_KEY")
+    @classmethod
+    def check_apt_prefix(cls, v: str) -> str:
+        if v and not v.startswith("apt-"):
+            raise ValueError("GAME key must start with 'apt-'")
+        return v
+
+    @field_validator("BUYER_AGENT_GAME_TWITTER_ACCESS_TOKEN", "SELLER_AGENT_GAME_TWITTER_ACCESS_TOKEN")
+    @classmethod
+    def check_apx_prefix(cls, v: str) -> str:
+        if v and not v.startswith("apx-"):
+            raise ValueError("SELLER_AGENT_GAME_TWITTER_ACCESS_TOKEN must start with 'apx-'")
+        return v
+