提交交互答复

当智能体任务处于 input-required 状态时,先读取任务状态消息中的待答复问题及输入请求标识,再按问题 ID 提交结构化答案并继续跟踪同一任务。

任务流程

处于 input-required 的任务 ID
              │
              ▼
  读取状态消息中的工具输入请求
              │
              ▼
提取 inputRequestId 与问题 ID 列表
              │
              ▼
   提交结构化答案并回查原任务状态

准备

  1. 已完成 使用 SDK 中的服务地址、个人访问令牌与工作区配置。

  2. 已通过 发现与选择智能体 获取原任务所属的智能体 ID。

  3. 已通过 调用智能体与跟踪任务 获取当前状态为 input-required 的任务 ID。

在终端设置智能体 ID 与等待输入的任务 ID:

export AGENT_ID='<原任务的智能体 ID>'
export AGENT_TASK_ID='<处于 input-required 状态的任务 ID>'

读取待答复问题

运行以下代码读取目标任务的当前状态消息,筛选工具调用产生的结构化输入请求(type 为 "moi.tool.call" 且含 inputRequestId),输出输入请求标识与问题列表。

import json
import os
import uuid

import moi_product_sdk as sdk

client = sdk.new_with_personal_access_token(
    os.environ["PRODUCT_API_BASE_URL"],
    os.environ["PRODUCT_API_KEY"],
)
workspace = client.workspace(os.environ["WORKSPACE_ID"])
agent = workspace.agent_by_id(os.environ["AGENT_ID"])

task_id = os.environ["AGENT_TASK_ID"]
task = sdk.agent_a2a_payload(agent.get_task(sdk.AgentTaskRequest(task_id)))
if task.get("id") != task_id or task.get("status", {}).get("state") != "input-required":
    raise RuntimeError("Task is not waiting for input")

parts = task.get("status", {}).get("message", {}).get("parts", [])
requests = [
    part.get("data", {})
    for part in parts
    if part.get("kind") == "data"
    and part.get("data", {}).get("type") == "moi.tool.call"
    and part.get("data", {}).get("inputRequestId")
]
for req in requests:
    print("inputRequestId:", req["inputRequestId"])
    print(
        "questions:",
        json.dumps(req.get("arguments", {}).get("questions", []), ensure_ascii=False),
    )
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"time"

	sdk "github.com/matrixorigin/matrixflow/sdk/go-sdk"
)

func main() {
	ctx := context.Background()
	client, err := sdk.NewWithPersonalAccessToken(
		os.Getenv("PRODUCT_API_BASE_URL"),
		os.Getenv("PRODUCT_API_KEY"),
	)
	if err != nil {
		panic(err)
	}
	defer client.Close()

	workspace, err := client.Workspace(os.Getenv("WORKSPACE_ID"))
	if err != nil {
		panic(err)
	}
	agent, err := workspace.AgentByID(os.Getenv("AGENT_ID"))
	if err != nil {
		panic(err)
	}

	taskID := os.Getenv("AGENT_TASK_ID")
	current, err := agent.GetTask(ctx, sdk.AgentTaskRequest{TaskID: taskID})
	if err != nil {
		panic(err)
	}
	task, err := sdk.AgentA2APayload(current)
	if err != nil {
		panic(err)
	}
	status, _ := task["status"].(map[string]any)
	if task["id"] != taskID || status["state"] != "input-required" {
		panic("Task is not waiting for input")
	}

	message, _ := status["message"].(map[string]any)
	parts, _ := message["parts"].([]any)
	for _, part := range parts {
		value, _ := part.(map[string]any)
		data, _ := value["data"].(map[string]any)
		if value["kind"] != "data" || data["type"] != "moi.tool.call" {
			continue
		}
		reqID, _ := data["inputRequestId"].(string)
		if reqID == "" {
			continue
		}
		arguments, _ := json.Marshal(data["arguments"])
		fmt.Println("inputRequestId:", reqID)
		fmt.Println("questions:", string(arguments))
	}
	_ = time.Now
}

提交交互答案

根据上一步输出的问题列表准备本地 JSON 文件 answers.json。顶层键填写问题的真实 id,对应值的 answers 数组填写所选或输入的答案(下方 report_scope 为示意问题 ID):

{
  "report_scope": {
    "answers": [
      "本季度"
    ]
  }
}

设置待答复的输入请求标识与答案文件路径后,接续同一智能体句柄提交答案,并核对响应中的任务 ID、状态和成果:

export INPUT_REQUEST_ID='<上一步输出的 inputRequestId>'
export ANSWERS_FILE='answers.json'
request_id = os.environ["INPUT_REQUEST_ID"]
if not any(req["inputRequestId"] == request_id for req in requests):
    raise RuntimeError("Selected inputRequestId is not pending on this task")

with open(os.environ["ANSWERS_FILE"], encoding="utf-8") as source:
    answers = json.load(source)

params = {
    "taskId": task_id,
    "requestId": request_id,
    "answers": answers,
}
result = agent.a2a(
    sdk.A2ARequest("matrixflow/input.submit", id_=str(uuid.uuid4()), params=params)
)
payload = sdk.agent_a2a_payload(result)
if payload.get("id") != task_id:
    raise RuntimeError("Response does not match the original task ID")

print("task_id:", payload.get("id"))
print("contextId:", payload.get("contextId"))
print("state:", payload.get("status", {}).get("state"))
for artifact in payload.get("artifacts", []):
    print("artifactId:", artifact.get("artifactId"))
    print("parts:", json.dumps(artifact.get("parts", []), ensure_ascii=False))
requestID := os.Getenv("INPUT_REQUEST_ID")
raw, err := os.ReadFile(os.Getenv("ANSWERS_FILE"))
if err != nil {
	panic(err)
}
var answers map[string]any
if err := json.Unmarshal(raw, &answers); err != nil {
	panic(err)
}

params, err := json.Marshal(map[string]any{
	"taskId":    taskID,
	"requestId": requestID,
	"answers":   answers,
})
if err != nil {
	panic(err)
}

result, err := agent.A2A(ctx, sdk.A2ARequest{
	JSONRPC: "2.0",
	ID:      fmt.Sprintf("submit-%d", time.Now().UnixNano()),
	Method:  sdk.A2AMethodInputSubmit,
	Params:  params,
})
if err != nil {
	panic(err)
}
payload, err := sdk.AgentA2APayload(result)
if err != nil {
	panic(err)
}
if payload["id"] != taskID {
	panic("Response does not match the original task ID")
}

fmt.Println("task_id:", payload["id"], "contextId:", payload["contextId"])
nextStatus, _ := payload["status"].(map[string]any)
fmt.Println("state:", nextStatus["state"])
artifacts, _ := json.Marshal(payload["artifacts"])
fmt.Println("artifacts:", string(artifacts))

限制和注意事项

  • 提交答案仅代表输入已被接收;若返回状态仍为 submitted 或 working,继续按原任务 ID 查询直至到达终态。

  • 若状态消息中的数据片段类型为 moi.provider_interaction.required,需通过 message/send 发送类型为 moi.provider_interaction.respond 的数据片段(携带该交互的 requestId、target 与 payload,取消时传 cancelled: true 并省略 payload),该类交互不使用 matrixflow/input.submit。

  • 包含敏感信息的答案文件应妥善设置本地权限,避免写入公共日志或版本库;当任务进入下一轮交互时,需重新读取最新 inputRequestId 与问题列表。

下一步

最后更新于