# 提交交互答复

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

(sdk-ai-studio-agent-input-flow)=
## 任务流程

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

(sdk-ai-studio-agent-input-prepare)=
## 准备

1. 已完成 [使用 SDK](../../../quickstart/ai-studio/sdk.md) 中的服务地址、个人访问令牌与工作区配置。
2. 已通过 [发现与选择智能体](发现与选择智能体.md#sdk-ai-studio-agents-s1) 获取原任务所属的智能体 ID。
3. 已通过 [调用智能体与跟踪任务](调用智能体并跟踪任务.md#sdk-ai-studio-agent-task-results) 获取当前状态为 `input-required` 的任务 ID。

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

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

(sdk-ai-studio-agent-input-read)=
## 读取待答复问题

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

:::::{tab-set}
:sync-group: sdk-language

::::{tab-item} Python
:sync: python

```python
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),
    )
```

::::

::::{tab-item} Go
:sync: go

```go
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
}
```

::::

:::::

(sdk-ai-studio-agent-input-submit)=
## 提交交互答案

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

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

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

```bash
export INPUT_REQUEST_ID='<上一步输出的 inputRequestId>'
export ANSWERS_FILE='answers.json'
```

:::::{tab-set}
:sync-group: sdk-language

::::{tab-item} Python
:sync: python

```python
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))
```

::::

::::{tab-item} Go
:sync: go

```go
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))
```

::::

:::::

(sdk-ai-studio-agent-input-protocol)=
## 限制和注意事项

- 提交答案仅代表输入已被接收；若返回状态仍为 `submitted` 或 `working`，继续按原任务 ID 查询直至到达终态。
- 若状态消息中的数据片段类型为 `moi.provider_interaction.required`，需通过 `message/send` 发送类型为 `moi.provider_interaction.respond` 的数据片段（携带该交互的 `requestId`、`target` 与 `payload`，取消时传 `cancelled: true` 并省略 `payload`），该类交互不使用 `matrixflow/input.submit`。
- 包含敏感信息的答案文件应妥善设置本地权限，避免写入公共日志或版本库；当任务进入下一轮交互时，需重新读取最新 `inputRequestId` 与问题列表。

(sdk-ai-studio-agent-input-next)=
## 下一步

- [调用智能体与跟踪任务](调用智能体并跟踪任务.md#sdk-ai-studio-agent-task-continue)
