Agents API

POST /api/v1/teams/{team_id}/agent/{agent_workflow_id}/a2a

{
  "jsonrpc": "2.0",
  "method": "message/send",  // 또는 "message/stream"
  "params": {
    "message": {
      "role": "user",
      "messageId": "msg-123456",
      "parts": [
        {
          "text": "사용자 질문"
        }
      ]
    },
    "metadata": {
      "chat_session_id": 123
    }
  },
  "id": "unique-request-id"
}

import requests
import json

class ClovaAgent:
    def __init__(self, api_key, team_id, agent_id, session_id):
        self.api_key = api_key
        self.base_url = "https://api.clovastudio.go.kr"
        self.team_id = team_id
        self.agent_id = agent_id
        self.session_id = session_id
    
    def execute(self, user_message):
        """에이전트 실행 (비스트리밍)"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        data = {
            "jsonrpc": "2.0",
            "method": "message/send",
            "params": {
                "message": {
                    "role": "user",
                    "messageId": f"msg-{int(time.time())}",
                    "parts": [
                        {"text": user_message}
                    ]
                },
                "metadata": {
                    "chat_session_id": self.session_id
                }
            },
            "id": f"req-{int(time.time())}"
        }
        
        response = requests.post(
            f"{self.base_url}/api/v1/teams/{self.team_id}/agent/{self.agent_id}/a2a",
            headers=headers,
            json=data
        )
        
        if response.status_code == 200:
            result = response.json()
            return result['result']['message']['parts'][0]['text']
        else:
            raise Exception(f"Agent Error: {response.status_code} - {response.text}")

# 사용 예제
agent = ClovaAgent(
    api_key="YOUR_API_KEY",
    team_id=1,
    agent_id=5,
    session_id=123
)

response = agent.execute("대한민국의 주요 국정과제는 무엇인가요?")
print(response)

interface A2ARequest {
  jsonrpc: "2.0";
  method: "message/send" | "message/stream";
  params: {
    message: {
      role: "user";
      messageId: string;
      parts: Array<{ text: string }>;
    };
    metadata: {
      chat_session_id: number;
    };
  };
  id: string;
}

class ClovaAgent {
  private apiKey: string;
  private baseUrl: string = "https://api.clovastudio.go.kr";
  private teamId: number;
  private agentId: number;
  private sessionId: number;

  constructor(apiKey: string, teamId: number, agentId: number, sessionId: number) {
    this.apiKey = apiKey;
    this.teamId = teamId;
    this.agentId = agentId;
    this.sessionId = sessionId;
  }

  async execute(userMessage: string): Promise<string> {
    const request: A2ARequest = {
      jsonrpc: "2.0",
      method: "message/send",
      params: {
        message: {
          role: "user",
          messageId: `msg-${Date.now()}`,
          parts: [{ text: userMessage }]
        },
        metadata: {
          chat_session_id: this.sessionId
        }
      },
      id: `req-${Date.now()}`
    };

    const response = await fetch(
      `${this.baseUrl}/api/v1/teams/${this.teamId}/agent/${this.agentId}/a2a`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(request)
      }
    );

    if (response.ok) {
      const result = await response.json();
      return result.result.message.parts[0].text;
    } else {
      throw new Error(`Agent Error: ${response.status} - ${await response.text()}`);
    }
  }
}

// 사용 예제
const agent = new ClovaAgent("YOUR_API_KEY", 1, 5, 123);
const response = await agent.execute("대한민국의 주요 국정과제는 무엇인가요?");
console.log(response);

import requests
import json

def execute_agent_stream(api_key, team_id, agent_id, session_id, user_message):
    """에이전트 스트리밍 실행"""
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    data = {
        "jsonrpc": "2.0",
        "method": "message/stream",  # 스트리밍 메서드
        "params": {
            "message": {
                "role": "user",
                "messageId": f"msg-{int(time.time())}",
                "parts": [
                    {"text": user_message}
                ]
            },
            "metadata": {
                "chat_session_id": session_id
            }
        },
        "id": f"req-stream-{int(time.time())}"
    }
    
    response = requests.post(
        f"https://api.clovastudio.go.kr/api/v1/teams/{team_id}/agent/{agent_id}/a2a",
        headers=headers,
        json=data,
        stream=True  # 스트리밍 활성화
    )
    
    full_response = ""
    
    for line in response.iter_lines():
        if line:
            line = line.decode('utf-8')
            if line.startswith('data: '):
                data_str = line[6:]
                if data_str == '[DONE]':
                    break
                try:
                    data = json.loads(data_str)
                    if 'result' in data and 'message' in data['result']:
                        parts = data['result']['message'].get('parts', [])
                        for part in parts:
                            if 'text' in part:
                                print(part['text'], end='', flush=True)
                                full_response += part['text']
                except json.JSONDecodeError:
                    continue
    
    print()  # 새 줄
    return full_response

# 사용 예제
response = execute_agent_stream(
    api_key="YOUR_API_KEY",
    team_id=1,
    agent_id=5,
    session_id=123,
    user_message="대한민국의 주요 국정과제는 무엇인가요?"
)

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32600,
    "message": "Invalid Request",
    "data": {
      "detail": "Missing required field: chat_session_id"
    }
  },
  "id": "req-123"
}