# 重新生成回答

基于已完成的智能体任务提供修改要求并生成新回答。程序先读取原任务的对话上下文 ID，提交分支模式的重新生成控制消息，再按返回的新任务 ID 查询状态和成果。

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

```text
已完成的原任务 ID（SOURCE_TASK_ID）
               │
               ▼
  读取原任务并获取对话上下文（contextId）
               │
               ▼
   提交 moi.run.control（regenerate）
               │
               ▼
       获取新任务 ID 并读取成果
```

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

1. 已完成 [使用 SDK](../../../quickstart/ai-studio/sdk.md) 中的服务地址、个人访问令牌与工作区配置。
2. 已通过 [发现与选择智能体](发现与选择智能体.md#sdk-ai-studio-agents-s1) 确认原任务所属的智能体 ID。
3. 已通过 [调用智能体与跟踪任务](调用智能体并跟踪任务.md#sdk-ai-studio-agent-task-results) 获取状态为 `completed` 的原任务 ID，并保持同一身份、工作区和智能体。
4. 为本次重新生成预先生成并保存控制标识与控制消息标识，避免网络超时后重复生成新标识再次提交。

在终端设置原任务信息与控制标识：

```bash
export AGENT_ID='<原任务的智能体 ID>'
export SOURCE_TASK_ID='<状态为 completed 的原任务 ID>'
export CONTROL_ID="$(python3 -c 'import uuid; print(uuid.uuid4())')"
export CONTROL_MESSAGE_ID="$(python3 -c 'import uuid; print(uuid.uuid4())')"
```

(sdk-ai-studio-agent-regenerate-send)=
## 发起重新生成并查询新任务

示例以对话分支模式（`conversationMode` 为 `"branch"`）请求智能体缩短句式并保留来源引用。重新生成会再次触发模型推理及可能关联的工具调用，运行前请确认原任务涉及的外部写入影响。

:::::{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"])

source_id = os.environ["SOURCE_TASK_ID"]
source = sdk.agent_a2a_payload(agent.get_task(sdk.AgentTaskRequest(source_id)))
if source.get("id") != source_id or source.get("status", {}).get("state") != "completed":
    raise RuntimeError("Select a completed source task")

context_id = source["contextId"]
control_id = os.environ["CONTROL_ID"]
message_id = os.environ["CONTROL_MESSAGE_ID"]

params = {
    "message": {
        "kind": "message",
        "role": "user",
        "messageId": message_id,
        "contextId": context_id,
        "taskId": source_id,
        "parts": [
            {
                "kind": "data",
                "data": {
                    "type": "moi.run.control",
                    "version": 1,
                    "controlId": control_id,
                    "action": "regenerate",
                    "rerunMode": "same_manifest",
                    "conversationMode": "branch",
                    "guidance": "Use shorter sentences and preserve all cited sources.",
                    "target": {
                        "agentId": os.environ["AGENT_ID"],
                        "contextId": context_id,
                        "taskId": source_id,
                    },
                },
            }
        ],
    }
}

try:
    result = agent.a2a(
        sdk.A2ARequest("message/send", id_=str(uuid.uuid4()), params=params)
    )
except sdk.Error as error:
    if error.details.get("task_id"):
        print("task_id:", error.details["task_id"])
    raise

ack = sdk.agent_a2a_payload(result)
new_id = ack.get("id", "") if ack.get("kind") == "task" else ""
if ack.get("kind") == "message":
    for part in ack.get("parts", []):
        data = part.get("data", {})
        if (
            data.get("type") == "moi.run.control.result"
            and data.get("controlId") == control_id
        ):
            new_id = data.get("taskId", "")
if not new_id or new_id == source_id:
    raise RuntimeError("No new task ID confirmed; retain the original control request")

print("new_task_id:", new_id)
payload = sdk.agent_a2a_payload(agent.get_task(sdk.AgentTaskRequest(new_id)))
print("task_id:", payload.get("id"))
print("contextId:", payload.get("contextId"))
print("state:", payload.get("status", {}).get("state"))
print(
    "status message:",
    json.dumps(payload.get("status", {}).get("message"), ensure_ascii=False),
)
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
package main

import (
	"context"
	"encoding/json"
	"errors"
	"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)
	}

	sourceID := os.Getenv("SOURCE_TASK_ID")
	sourceResult, err := agent.GetTask(ctx, sdk.AgentTaskRequest{TaskID: sourceID})
	if err != nil {
		panic(err)
	}
	source, err := sdk.AgentA2APayload(sourceResult)
	if err != nil {
		panic(err)
	}
	sourceStatus, _ := source["status"].(map[string]any)
	if source["id"] != sourceID || sourceStatus["state"] != "completed" {
		panic("Select a completed source task")
	}

	contextID, _ := source["contextId"].(string)
	controlID := os.Getenv("CONTROL_ID")
	messageID := os.Getenv("CONTROL_MESSAGE_ID")
	if controlID == "" || messageID == "" {
		panic("Set both CONTROL_ID and CONTROL_MESSAGE_ID before sending")
	}

	params, err := json.Marshal(map[string]any{
		"message": map[string]any{
			"kind":      "message",
			"role":      "user",
			"messageId": messageID,
			"contextId": contextID,
			"taskId":    sourceID,
			"parts": []any{
				map[string]any{
					"kind": "data",
					"data": map[string]any{
						"type":             "moi.run.control",
						"version":          1,
						"controlId":        controlID,
						"action":           "regenerate",
						"rerunMode":        "same_manifest",
						"conversationMode": "branch",
						"guidance":         "Use shorter sentences and preserve all cited sources.",
						"target": map[string]any{
							"agentId":   os.Getenv("AGENT_ID"),
							"contextId": contextID,
							"taskId":    sourceID,
						},
					},
				},
			},
		},
	})
	if err != nil {
		panic(err)
	}

	result, err := agent.A2A(ctx, sdk.A2ARequest{
		JSONRPC: "2.0",
		ID:      fmt.Sprintf("request-%d", time.Now().UnixNano()),
		Method:  sdk.A2AMethodSend,
		Params:  params,
	})
	if err != nil {
		var apiError *sdk.Error
		if errors.As(err, &apiError) && apiError.Details["task_id"] != "" {
			fmt.Println("task_id:", apiError.Details["task_id"])
		}
		panic(err)
	}

	ack, err := sdk.AgentA2APayload(result)
	if err != nil {
		panic(err)
	}
	newID := ""
	if ack["kind"] == "task" {
		newID, _ = ack["id"].(string)
	}
	if ack["kind"] == "message" {
		parts, _ := ack["parts"].([]any)
		for _, part := range parts {
			value, _ := part.(map[string]any)
			data, _ := value["data"].(map[string]any)
			if data["type"] == "moi.run.control.result" && data["controlId"] == controlID {
				newID, _ = data["taskId"].(string)
			}
		}
	}
	if newID == "" || newID == sourceID {
		panic("No new task ID confirmed; retain the original control request")
	}

	fmt.Println("new_task_id:", newID)
	current, err := agent.GetTask(ctx, sdk.AgentTaskRequest{TaskID: newID})
	if err != nil {
		panic(err)
	}
	payload, err := sdk.AgentA2APayload(current)
	if err != nil {
		panic(err)
	}
	fmt.Println("task_id:", payload["id"], "contextId:", payload["contextId"])
	status, _ := payload["status"].(map[string]any)
	fmt.Println("state:", status["state"])
	message, _ := json.Marshal(status["message"])
	fmt.Println("status message:", string(message))
	artifacts, _ := json.Marshal(payload["artifacts"])
	fmt.Println("artifacts:", string(artifacts))
}
```

::::

:::::

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

- 控制响应可能直接返回新任务对象，也可能返回携带 `moi.run.control.result` 的控制确认消息；确认消息中的 `created` 状态仅表示重新生成操作已立项，需以新任务的 `completed` 状态和 `artifacts` 判断最终结果。
- 发生网络超时或连接中断时，保留原有的 `CONTROL_ID`、`CONTROL_MESSAGE_ID` 和已获取的新任务 ID 先做查询，避免更换控制标识重复发起执行。
- 本页用于触发模型重新生成回答；仅修改已存储会话记录文本时，请参见 [管理会话记录](../会话记录.md#sdk-ai-studio-conversation-records-maintain)。

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

- [调用智能体与跟踪任务](调用智能体并跟踪任务.md#sdk-ai-studio-agent-task-continue)
- [管理会话记录](../会话记录.md#sdk-ai-studio-conversation-records-maintain)
