자율 에이전트 일정 예약

대규모 문서 합성 및 장기 실행 연구와 같은 다단계 에이전트 워크플로를 배포할 때 실시간 모델에서 백그라운드 에이전트를 실행하면 불필요한 인프라 부담이 발생하고 리소스 소진(429) 오류가 발생할 수 있습니다.

Gemini Enterprise Agent Platform은 지연 시간을 허용하는 워크로드를 위해 특별히 설계된 처리량 최적화 스케줄러인 지연 등급을 제공합니다. 스케줄러는 장기 실행 자율 작업을 실시간 채팅 쿼리와 동일한 긴급도로 처리하는 대신, 높은 성공률과 전반적인 처리량을 목표로 복잡한 다단계 에이전트 워크플로를 사용량이 적은 시간대로 큐에 추가합니다.

지연 등급을 사용하여 요청을 제출하면 API는 비동기식으로 작업을 수락하고 상호작용 ID를 즉시 반환합니다. 지연 등급에는 다음과 같은 기능이 있습니다.

  • 할인 요율: 표준 요청에 비해 모델 추론 가격이 50% 할인되므로 프로덕션에서 에이전트 비용을 관리할 수 있습니다. 자세한 내용은 가격 책정을 참조하세요.

  • 더 높은 처리량: 지연 등급은 과중한 비동기 워크로드를 사용량이 적은 시간대로 이동하여 429(모델 용량 제약 조건) 및 비율 제한을 완화하므로 실시간 프로덕션 요구사항에 맞게 표준 등급 할당량을 확보할 수 있습니다.

  • 완료 제한 시간: 지연 등급은 24시간 이내에 태스크의 95% 를 완료하는 것을 목표로 합니다. 이 기간 내에 태스크가 완료되지 않으면 만료되고 failed 상태로 전환됩니다. 큐에서 소요되는 실제 시간은 현재 리전 클러스터 용량 및 수요에 따라 달라집니다.

사용 사례

지연 등급은 다음과 같은 예시와 같이 몇 시간의 처리 시간을 허용할 수 있는 사용 사례에 적합합니다.

  • 금융: 일일 또는 주간 주식 및 시장 조사

  • 법률 및 규정 준수: 여러 문서에 대한 규제 및 인수합병 실사

  • 전략: 지속적인 경쟁 인텔리전스 및 트렌드 종합

  • 보안: 코드베이스 취약점 스캔 및 수정

고객 지원 담당자

다음 에이전트에 대해 자율 에이전트 예약을 구성할 수 있습니다. 에이전트를 선택하여 설정 안내로 이동합니다.

Gemini 모델에서 커스텀 또는 서드 파티 에이전트 루프를 직접 실행하려면 지연 등급 사용을 참조하세요.

ADK 에이전트 예약

ADK에서는 에이전트나 모델에 고정 등급을 구성하는 대신 호출당 RunConfig에서 service_tier 파라미터를 설정합니다. service_tier=ServiceTier.DEFERRED를 설정하면 각 모델 호출이 사용량이 적은 시간대 용량 풀에 큐에 추가되는 반면 기본 ServiceTier.STANDARD는 동기식으로 실행됩니다. 이 실행별 설정을 사용하면 하나의 에이전트 정의가 대화형 요청과 오프라인 일괄 워크플로를 모두 처리할 수 있습니다.

ADK 에이전트에 지연된 요청을 보내면 ADK가 백그라운드 제출, 폴링, 검색을 자동으로 처리합니다.

  1. ADK는 백그라운드 실행이 사용 설정된 상태로 모델 요청을 제출하고 백엔드는 queued 또는 in_progress 상태의 상호작용 ID를 반환합니다.
  2. 상호작용이 대기 중인 동안 ADK는 지수 백오프를 사용하여 백엔드를 폴링합니다.
  3. 상호작용이 최종 상태에 도달하면 ADK는 완료된 상호작용을 실행기 인터페이스를 통해 사용하는 표준 모델 응답 이벤트로 변환합니다.

이 섹션에서는 ADK 에이전트 예약과 관련된 다음 작업을 설명합니다.

ADK의 ServiceTier 구성에 관한 자세한 내용은 ADK 문서의 지연된 예약을 참고하세요.

ADK 에이전트 제한사항

지연 등급에서 ADK 에이전트를 예약할 때는 다음 요구사항 및 제한사항을 고려하세요.

  • Interactions API 필요: 서빙 등급은 Gemini(use_interactions_api=True)와 같이 Interactions API에 구성된 모델에만 적용됩니다. 표준 콘텐츠 생성 모델은 ManagedAgent를 무시합니다service_tier.
  • 토큰 스트리밍과 호환되지 않음: 지연된 실행은 RunConfig의 StreamingMode.SSE와 결합할 수 없습니다. /run_sse를 호출할 때 streaming를 생략하거나 "streaming": false를 설정합니다. "service_tier": "deferred"와 함께 "streaming": true를 전달하면 HTTP 422 Unprocessable Entity가 반환됩니다.
  • HTTP 연결 한도: adk api_server에서 /run 및 /run_sse는 큐 대기 중에 HTTP 연결을 열어 둡니다. 프록시 또는 플랫폼 제한 시간으로 인해 연결이 종료되면(예: Cloud Run의 60분 제한) 클라이언트 폴링이 중지됩니다. 백엔드 상호작용은 완료될 때까지 계속 실행되며 요금이 청구됩니다.
  • 대화당 큐 지연 시간: 멀티턴 또는 도구 호출 워크플로에서 각 모델 대화는 별도의 상호작용 요청을 제출합니다. 차례가 올 때마다 비성수기 대기열 대기가 발생합니다.
  • 다시 시작 시 진행 중인 상호작용 재개 불가: ADK는 진행 중인 상호작용 ID를 세션 저장소에 유지하거나 연결이 끊긴 상호작용에 다시 연결하지 않습니다. 클라이언트 프로세스를 중지하면 대기 중인 폴링 루프가 중단되고 후속 호출에서 새 상호작용이 시작됩니다.

지연 등급에서 ADK 에이전트 실행

지연 등급에서 ADK 에이전트를 예약하려면 use_interactions_api=True로 Gemini 모델을 구성하고 러너를 호출할 때 RunConfig(service_tier=ServiceTier.DEFERRED)를 전달합니다.

import asyncio

from google.adk.agents import LlmAgent
from google.adk.agents import RunConfig
from google.adk.apps import App
from google.adk.models import ServiceTier
from google.adk.models.google_llm import Gemini
from google.adk.runners import InMemoryRunner
from google.genai import types

root_agent = LlmAgent(
    name="batch_agent",
    model=Gemini(
        model="gemini-3.5-flash",
        use_interactions_api=True,
        client_kwargs={
            "enterprise": True,
            "project": "PROJECT_ID",
            "location": "global",
        },
    ),
    instruction="Process input documents and produce summaries.",
)

app = App(
    name="batch_app",
    root_agent=root_agent,
)

runner = InMemoryRunner(app=app)


async def main() -> None:
  session = await runner.session_service.create_session(
      app_name=app.name,
      user_id="user_123",
      session_id="session_456",
  )

  run_config = RunConfig(service_tier=ServiceTier.DEFERRED)

  async for event in runner.run_async(
      user_id="user_123",
      session_id=session.id,
      new_message=types.Content(
          role="user",
          parts=[
              types.Part.from_text(
                  text="Summarize quarterly performance metrics."
              )
          ],
      ),
      run_config=run_config,
  ):
    if event.content and event.content.parts:
      for part in event.content.parts:
        if part.text:
          print(part.text)


asyncio.run(main())

PROJECT_ID를 Google Cloud 프로젝트 ID로 바꿉니다.

상호작용 상태가 queued 또는 in_progress인 동안 runner.run_async()는 상호작용이 완료될 때까지 이벤트를 생성하지 않습니다. 애플리케이션 로그에서 다음 메시지를 확인하여 지연 등급이 활성 상태인지 확인합니다.

  • INFO 수준에서 상호작용은 로그 Interaction INTERACTION_ID is queued; waiting for the result. 및 Interaction INTERACTION_ID reached status completed.를 전송합니다. 디버그 로깅이 사용 설정되면 요청 프로세서도 Using service_tier from run_config: ServiceTier.DEFERRED를 로깅합니다.
  • 모델에 use_interactions_api=True가 설정되지 않은 경우 ADK는 service_tier를 무시하고 표준 생성을 진행하며 모델이 Interactions API를 사용하지 않는다는 경고를 로깅합니다.

지연된 ADK 에이전트 배포

에이전트 정의가 아닌 요청별로 service_tier를 구성하므로 하나의 ADK 에이전트 패키지(use_interactions_api=True)가 실시간 워크로드와 지연된 워크로드를 모두 처리할 수 있습니다. 이 패키지를 Agent Runtime, Cloud Run 또는 GKE에 배포할 수 있습니다.

다음 표에서는 지연된 ADK 워크로드의 배포 옵션을 비교합니다.

배포 옵션 사용 시기 실행 모델 최대 제한 시간 지연 등급을 요청하는 방법
Agent Runtime Agent Platform이 세션을 관리하고, HTTP 연결을 열어 두지 않고 실행되며, 결과를 Cloud Storage에 직접 쓰는 비동기 백그라운드 작업 관리형 백그라운드 작업(run_query_job) 168시간(7일, 모델 차례당 24시간) input 내부의 "run_config": {"service_tier": "deferred"}
Cloud Run 서비스 60분 이내에 완료되는 대화형 요청과 지연된 워크로드를 모두 처리하는 서버리스 HTTPS 엔드포인트 서버리스 HTTP 또는 SSE(adk deploy cloud_run) 60분(3,600초) /run 또는 /run_sse("streaming": false 포함) 요청 본문의 "service_tier": "deferred"
Cloud Run 작업 60분 이상(모델 차례당 최대 24시간) 대기할 수 있는 HTTP 연결이 없는 서버리스 일괄 워크로드 서버리스 일괄 컨테이너(gcloud run jobs) 168시간(7일) RunConfig(service_tier=ServiceTier.DEFERRED)
GKE 커스텀 네트워킹, 포드 수명 주기 제어 또는 서버리스 요청 제한 시간 제한이 없는 Kubernetes 워크로드 Kubernetes 포드(adk deploy gke) 무제한(포드 및 인그레스 구성됨) /run 또는 /run_sse("streaming": false 포함) 요청 본문의 "service_tier": "deferred"

배포가 리전 엔드포인트(예: us-central1)에서 실행되는 동안 모델이 global 엔드포인트를 사용하는 경우 client_kwargs={"location": "global"}를 Gemini(...)에 전달합니다. 런타임 서비스 계정에 프로젝트에 대한 Agent Platform 사용자(roles/aiplatform.user) 역할이 있는지 확인합니다.

구성 안내를 보려면 배포 대상을 선택하세요.

Agent Runtime

에이전트를 Agent Runtime에 배포할 때 agent_framework="google-adk"를 설정하고 requirements에 google-adk>=2.10.0를 포함합니다. 작업이 스테이징된 입력 쿼리를 읽고 출력을 작성할 수 있도록 에이전트의 구성된 런타임 ID(격리된 에이전트 ID 또는 전용 커스텀 서비스 계정 선호, 에이전트가 기본 서비스 에이전트를 사용하는 경우에만 기본 AI Platform Reasoning Engine 서비스 에이전트 service-PROJECT_NUMBER@gcp-sa-aiplatform-re. 사용)에 버킷에 대한 스토리지 객체 생성자(roles/storage.objectCreator) 및 스토리지 객체 뷰어(roles/storage.objectViewer)를 모두 부여합니다. 에이전트의 프로젝트에 이미 storage.objects.get가 있는 기본 gcp-sa-aiplatform-re 서비스 에이전트를 사용하는 경우에만 roles/storage.objectCreator만으로 충분합니다.

비동기 지연 장기 실행 쿼리 작업을 제출하려면 client.runtimes.run_query_job()를 호출하고 input 내에 "run_config": {"service_tier": "deferred"}를 전달합니다.

import json
import agentplatform

client = agentplatform.Client(
    project="PROJECT_ID",
    location="LOCATION",
)

job = client.runtimes.run_query_job(
    name=(
        "projects/PROJECT_ID"
        "/locations/LOCATION"
        "/reasoningEngines/RESOURCE_ID"
    ),
    config={
        "query": json.dumps({
            "class_method": "async_stream_query",
            "input": {
                "user_id": "USER_ID",
                "session_id": "SESSION_ID",
                "message": "Summarize quarterly performance metrics.",
                "run_config": {"service_tier": "deferred"},
            },
        }),
        "output_gcs_uri": (
            "gs://BUCKET_NAME"
            "/OUTPUT_FILE.jsonl"
        ),
    },
)

다음을 바꿉니다.

  • PROJECT_ID: Google Cloud 프로젝트 ID입니다.
  • LOCATION: 에이전트가 배포된 지원되는 지역(예: us-central1)
  • RESOURCE_ID: 배포된 reasoningEngine 리소스의 숫자 ID입니다.
  • USER_ID 및 SESSION_ID: 호출의 사용자 및 세션 식별자입니다.
  • BUCKET_NAME 및 OUTPUT_FILE: Agent Runtime이 스트리밍된 이벤트를 줄바꿈으로 구분된 JSON(application/x-ndjson, 줄당 JSON 객체 하나)으로 작성하는 Cloud Storage 버킷 및 객체 프리픽스입니다.

Cloud Run

예상 큐 기간에 따라 Cloud Run 서비스 또는 Cloud Run 작업을 구성합니다.

  • Cloud Run 서비스(adk deploy cloud_run): HTTPS 엔드포인트(/run 및 /run_sse) 뒤에 adk api_server를 배포합니다. Cloud Run이 기본 5분 제한 시간 후에 HTTP 연결을 닫지 않도록 배포 시 -- --timeout=3600를 전달합니다.

    adk deploy cloud_run \
      --project=PROJECT_ID \
      --region=LOCATION \
      --service_name=SERVICE_NAME \
      AGENT_DIR \
      -- --no-allow-unauthenticated --timeout=3600
    

    다음을 바꿉니다.

    • PROJECT_ID: Google Cloud 프로젝트 ID입니다.
    • LOCATION: Cloud Run 리전(예: us-central1)
    • SERVICE_NAME: Cloud Run 서비스 이름입니다.
    • AGENT_DIR: 에이전트 소스 디렉터리의 경로입니다.

    /run 또는 /run_sse를 호출하기 전에 POST /apps/APP_NAME/users/USER_ID/sessions로 세션을 만듭니다. 여기서 APP_NAME는 기본적으로 에이전트 디렉터리 이름입니다. 지연 실행을 요청하려면 JSON 요청 본문에 "service_tier": "deferred"를 최상위 필드로 포함합니다. /run_sse를 호출할 때 streaming를 생략하거나 "streaming": false를 설정합니다("streaming": true를 전달하면 HTTP 422 Unprocessable Entity가 반환됨).

    {
      "app_name": "batch_app",
      "user_id": "user_123",
      "session_id": "session_456",
      "new_message": {
        "role": "user",
        "parts": [{"text": "Summarize batch results."}]
      },
      "service_tier": "deferred",
      "streaming": false
    }
    
  • Cloud Run 작업(gcloud run jobs deploy): HTTP 요청 수명 주기 없이 컨테이너를 완료까지 실행하고 --task-timeout 최대 168시간(7일)을 지원합니다. 작업 진입점에서 RunConfig(service_tier=ServiceTier.DEFERRED)를 runner.run_async()에 전달하고 --task-timeout=86400s(24시간)로 배포합니다.

GKE

adk deploy gke를 사용하여 ADK 에이전트를 패키징하고 GKE 클러스터에 배포합니다.

adk deploy gke \
  --project=PROJECT_ID \
  --region=LOCATION \
  --cluster_name=CLUSTER_NAME \
  --service_name=SERVICE_NAME \
  AGENT_DIR

다음을 바꿉니다.

  • PROJECT_ID: Google Cloud 프로젝트 ID입니다.
  • LOCATION: 리전 GKE 클러스터의 리전입니다(예: us-central1).
  • CLUSTER_NAME: GKE 클러스터의 이름입니다.
  • SERVICE_NAME: 에이전트의 Kubernetes 서비스 이름입니다.
  • AGENT_DIR: 에이전트 소스 디렉터리의 경로입니다.

/run 또는 /run_sse를 호출하기 전에 POST /apps/APP_NAME/users/USER_ID/sessions로 세션을 만듭니다. 여기서 APP_NAME는 기본적으로 에이전트 디렉터리 이름입니다. 지연 실행을 요청하려면 JSON 요청 본문에 "service_tier": "deferred"를 최상위 필드로 포함합니다. /run_sse를 호출할 때 streaming를 생략하거나 "streaming": false를 설정합니다("streaming": true를 전달하면 HTTP 422 Unprocessable Entity가 반환됨).

{
  "app_name": "batch_app",
  "user_id": "user_123",
  "session_id": "session_456",
  "new_message": {
    "role": "user",
    "parts": [{"text": "Summarize batch results."}]
  },
  "service_tier": "deferred",
  "streaming": false
}

/run 및 /run_sse에 대한 요청은 큐 대기 및 모델 실행 중에 HTTP 연결을 열어 둡니다. 예상되는 큐 지연을 수용하도록 GKE 인그레스 및 부하 분산기 백엔드 제한 시간을 늘립니다. 클라이언트 연결이 닫히거나 타임아웃되면 서버는 로컬 폴링을 취소합니다. 백엔드 상호작용은 출력을 반환하지 않고 계속 실행되며 요금이 청구됩니다.

클라이언트 기한 적용

ADK는 큐 대기에 클라이언트 측 제한 시간을 적용하지 않고 백엔드의 24시간 완료 제한 시간에 의존합니다. 애플리케이션에서 총 경과 대기 시간을 제한하려면 runner.run_async()를 asyncio.timeout()로 래핑합니다.

import asyncio
import logging

from google.adk.agents import RunConfig
from google.adk.models import ServiceTier
from google.genai import types

logger = logging.getLogger(__name__)


# Continues from the earlier example using existing runner and session objects:
async def run_with_deadline(runner, session) -> None:
  message = types.Content(
      role="user",
      parts=[
          types.Part.from_text(text="Generate quarterly financial summary.")
      ],
  )
  run_config = RunConfig(service_tier=ServiceTier.DEFERRED)

  try:
    async with asyncio.timeout(300):
      async for event in runner.run_async(
          user_id="user_123",
          session_id=session.id,
          new_message=message,
          run_config=run_config,
      ):
        if event.content and event.content.parts:
          for part in event.content.parts:
            if part.text:
              print(part.text)
  except TimeoutError:
    logger.error(
        "Client timeout exceeded after 300 seconds. The deferred interaction"
        " continues to run and incur billing on the backend, so its output"
        " cannot be retrieved."
    )

클라이언트 제한 시간을 적용하면 다음 절전 간격에서 클라이언트 측 폴링 루프가 중지되지만 백엔드에서 작업이 취소되지는 않습니다. 클라이언트 제한 시간 이후에도 상호작용은 완료될 때까지 계속 실행되고 서버에 요금이 청구됩니다.

Gemini Deep Research 에이전트 예약

Interactions API를 사용하여 지연된 Deep Research 작업을 만들고, 모니터링하고, 취소하고, 결과를 가져옵니다.

지연된 태스크 만들기

다음 예시에서는 client.interactions.create()를 사용하여 지연 등급으로 Deep Research 작업을 시작하는 방법을 보여줍니다.

import time
from google import genai

client = genai.Client(
    enterprise=True,
    project="PROJECT_ID",
    location="global",
)

PROMPT = "Analyze the latest market trends in renewable energy storage."
DEEP_RESEARCH_AGENT = "deep-research-preview-04-2026"

interaction = client.interactions.create(
    input=PROMPT,
    agent=DEEP_RESEARCH_AGENT,  # Agent identifier
    service_tier="deferred",  # Run on deferred tier for off-peak scheduling
    background=True,  # Return immediately instead of waiting for the answer
    store=True,  # Persist interaction state to poll or stream later
    stream=False,  # `stream` must be set to False during task creation
)

print(f"Interaction ID: {interaction.id}")
print(f"Status:         {interaction.status}")
print(f"Service tier:   {interaction.service_tier}")

PROJECT_ID를 Google Cloud 프로젝트 ID로 바꿉니다.

이 메서드는 status="queued" 또는 status="in_progress" 및 service_tier="deferred"를 즉시 반환합니다.

태스크 진행률을 모니터링합니다.

비수기 용량을 기다리는 동안 활성 상태로 실행되는 경우 상호작용 status은 queued 또는 in_progress입니다. 에이전트가 계획, 검색, 분석 단계를 실행하면 새 항목이 steps 목록에 추가됩니다.

상호작용을 주기적으로 폴링하거나 업데이트를 스트리밍하여 프로그래매틱 방식으로 작업 상태를 추적할 수 있습니다.

폴링

상호작용이 completed, failed, cancelled 또는 incomplete 중 하나의 터미널 상태에 도달할 때까지 상호작용을 주기적으로(예: 15~30초마다) 폴링합니다.

TERMINAL_STATES = ("completed", "failed", "cancelled", "incomplete")
POLL_INTERVAL_SECONDS = 15
TIMEOUT_MINUTES = 60

started = time.time()
deadline = started + TIMEOUT_MINUTES * 60

while True:
  current = client.interactions.get(interaction.id)
  elapsed = int(time.time() - started)
  steps = getattr(current, "steps", None) or []
  print(f"[{elapsed:>4}s] status={current.status} steps={len(steps)}")

  if current.status in TERMINAL_STATES:
    break
  if time.time() >= deadline:
    raise TimeoutError(
        f"Still {current.status} after {TIMEOUT_MINUTES} min. The interaction "
        "continues running server-side; re-run the check to resume polling."
    )
  time.sleep(POLL_INTERVAL_SECONDS)

print(f"\nFinished in {int(time.time() - started)}s with status={current.status}.")

스트리밍

stream=True를 사용하여 client.interactions.get()를 호출하면 실시간 업데이트를 구독할 수 있습니다. 상호작용이 in_progress 상태로 전환되면 스트림은 중간 생각, 텍스트 델타, 상태 업데이트와 같은 이벤트를 발생하는 대로 푸시합니다.

작업이 아직 queued 또는 in_progress인 동안 연결이 끊어지면 stream=True와 함께 client.interactions.get()를 사용하여 스트림에 다시 연결하고 마지막으로 수신된 이벤트 ID를 last_event_id에 전달합니다. last_event_id를 생략하면 API가 처음부터 모든 이벤트를 재생합니다.

INTERACTION_ID = interaction.id  # from the create step
MAX_RECONNECTS = 5
STREAM_TIMEOUT = 300  # seconds

print(
    f"streaming interaction: {INTERACTION_ID} (status={interaction.status})\n"
)

def render(event):
  """Prints one SSE event. Returns True once the interaction has finished."""
  if event.event_type == "step.delta":
    delta = event.delta
    if delta.type == "text":
      print(delta.text, end="", flush=True)
    elif delta.type == "thought_summary":
      summary = (getattr(delta.content, "text", "") or "").strip()
      if summary:
        print(f"\n[thinking] {summary[:200]}", flush=True)
    elif delta.type.endswith("_call"):
      queries = getattr(getattr(delta, "arguments", None), "queries", None)
      print(
          f"\n[{delta.type}] {', '.join(queries) if queries else ''}",
          flush=True,
      )
  elif event.event_type == "interaction.status_update":
    print(f"[status] {event.status}", flush=True)
  elif event.event_type == "interaction.completed":
    print(f"\n\n[status] {event.interaction.status}", flush=True)
    return True
  elif event.event_type == "error":
    print(f"\n[error] {event.error.message}", flush=True)
    return True
  return False

last_event_id = None
finished = False

for attempt in range(MAX_RECONNECTS):
  try:
    # stream=True turns the GET into a live subscription. last_event_id=None on
    # the first pass, so the server starts from the beginning of the run.
    for event in client.interactions.get(
        INTERACTION_ID,
        stream=True,
        last_event_id=last_event_id,
        timeout=STREAM_TIMEOUT,
    ):
      last_event_id = event.event_id or last_event_id
      finished = render(event) or finished
  except Exception as e:  # pylint: disable=broad-except
    # A dropped connection loses nothing: the run continues server-side and the
    # next iteration reattaches from last_event_id.
    print(f"\n[stream dropped: {type(e).__name__}] reattaching...", flush=True)

  if finished:
    break
  # The server also closes the stream when the run ends, without an error.
  if client.interactions.get(
      INTERACTION_ID, timeout=STREAM_TIMEOUT
  ).status not in ("queued", "in_progress"):
    break
else:
  print(f"\n[gave up after {MAX_RECONNECTS} reconnects]")

print(f"\n\nStreamed interaction: {INTERACTION_ID}")

태스크 취소

상태가 queued, in_progress 또는 requires_action인 동안 작업을 취소할 수 있습니다. 태스크를 취소하면 상태가 cancelled로 전환됩니다.

태스크를 취소하려면 client.interactions.cancel()를 사용합니다.

client.interactions.cancel(interaction.id)

최종 출력 및 토큰 사용량 검색

상호작용이 completed 상태에 도달하면 steps 목록에서 전체 스크립트를 사용할 수 있습니다. 최종 답변은 마지막 model_output 단계의 텍스트 콘텐츠입니다.

상호작용이 저장되므로(store=True) 세션의 상호작용 ID를 사용하여 언제든지 결과를 가져올 수 있습니다.

def get_final_text(completed_interaction):
  """Returns the text of the last model_output step."""
  for step in reversed(getattr(completed_interaction, "steps", None) or []):
    if getattr(step, "type", None) != "model_output":
      continue
    text = "".join(
        part.text
        for part in (getattr(step, "content", None) or [])
        if getattr(part, "text", None)
    )
    if text:
      return text
  return ""


final = client.interactions.get(interaction.id)
print(f"Status: {final.status}\n")
print(get_final_text(final) or "(No text output)")

if final.usage:
  print(
      f"\nToken usage:\n"
      f"  Input tokens:  {final.usage.total_input_tokens}\n"
      f"  Output tokens: {final.usage.total_output_tokens}\n"
      f"  Total tokens:  {final.usage.total_tokens}"
  )

다음 단계

비동기 모델 호출, 스테이트풀(Stateful) 상호작용, 관리형 연구 에이전트에 관한 관련 가이드를 살펴보세요.