112 lines
3.8 KiB
Go
112 lines
3.8 KiB
Go
// 画布生成的结构化 IPC 输出;图片以字节传到核心,再由平台资产流程验证和持久化。
|
|
package codex
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
)
|
|
|
|
// CanvasImageBytesLimit 限制原始图片总字节,响应上限另为 JSON/base64 编码留出空间。
|
|
const CanvasImageBytesLimit = 20 << 20
|
|
const canvasArtifactResponseLimit = 32 << 20
|
|
|
|
// CanvasImage 的 Data 在 JSON 中编码为 base64,仅用于私有 Unix 通道。
|
|
type CanvasImage struct {
|
|
MIME string `json:"mime_type"`
|
|
Data []byte `json:"data"`
|
|
}
|
|
|
|
// CanvasOutput 用 Kind 区分文本和图片,由 GenerateOutput 再校验形态与请求模态相符。
|
|
type CanvasOutput struct {
|
|
Kind string `json:"kind"`
|
|
Text string `json:"text,omitempty"`
|
|
Image *CanvasImage `json:"image,omitempty"`
|
|
}
|
|
|
|
// Encoded image bytes exist only on the private Unix IPC channel. Public Canvas
|
|
// jobs expose stable asset IDs/URLs and never serialize these bytes to browsers.
|
|
// GenerateOutput 先检查输入预算,再发送 IPC;映射稳定错误码,兼容旧 worker 的 result 文本字段。
|
|
func (c *CanvasClient) GenerateOutput(ctx context.Context, input CanvasTask) (CanvasOutput, error) {
|
|
if c == nil {
|
|
return CanvasOutput{}, errors.New("codex_unavailable")
|
|
}
|
|
if len(input.Prompt) > CanvasInputLimit || len(input.Images) > 4 {
|
|
return CanvasOutput{}, errors.New("context_too_large")
|
|
}
|
|
total := 0
|
|
for _, image := range input.Images {
|
|
total += len(image.Data)
|
|
}
|
|
if total > CanvasImageBytesLimit {
|
|
return CanvasOutput{}, errors.New("context_too_large")
|
|
}
|
|
raw, err := json.Marshal(input)
|
|
if err != nil {
|
|
return CanvasOutput{}, err
|
|
}
|
|
request, err := http.NewRequestWithContext(ctx, "POST", "http://codex/canvas/exec", bytes.NewReader(raw))
|
|
if err != nil {
|
|
return CanvasOutput{}, err
|
|
}
|
|
response, err := c.client.Do(request)
|
|
if err != nil {
|
|
return CanvasOutput{}, err
|
|
}
|
|
defer response.Body.Close()
|
|
// 多读一字节区分刚好达到上限与实际超限,防止截断响应被当成成功结果。
|
|
raw, err = io.ReadAll(io.LimitReader(response.Body, canvasArtifactResponseLimit+1))
|
|
if err != nil || len(raw) > canvasArtifactResponseLimit {
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
var result struct {
|
|
Result string `json:"result"`
|
|
Output *CanvasOutput `json:"output"`
|
|
Error string `json:"error"`
|
|
}
|
|
if json.Unmarshal(raw, &result) != nil {
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
if response.StatusCode != 200 {
|
|
switch result.Error {
|
|
case "codex_timeout":
|
|
return CanvasOutput{}, errors.New("generation_timeout")
|
|
case "codex_busy":
|
|
if response.StatusCode == 429 {
|
|
return CanvasOutput{}, errors.New("codex_busy")
|
|
}
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
case "context_too_large":
|
|
return CanvasOutput{}, errors.New("context_too_large")
|
|
case "model_unavailable":
|
|
return CanvasOutput{}, errors.New("model_unavailable")
|
|
default:
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
}
|
|
// 旧响应只允许回退到文本;图片请求缺少结构化图片时必须失败。
|
|
if result.Output == nil {
|
|
if input.OutputModality == "image" {
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
return CanvasOutput{Kind: "text", Text: result.Result}, nil
|
|
}
|
|
output := *result.Output
|
|
switch output.Kind {
|
|
case "text":
|
|
if len(output.Text) > maxOutput || output.Image != nil || input.OutputModality == "image" {
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
case "image":
|
|
if output.Image == nil || len(output.Image.Data) == 0 || len(output.Image.Data) > CanvasImageBytesLimit || input.OutputModality != "image" {
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
default:
|
|
return CanvasOutput{}, errors.New("generation_failed")
|
|
}
|
|
return output, nil
|
|
}
|