Z AI SDK Go - API 文档

import "cnb.cool/S.o/z-ai-sdk-go/client"

// 从配置文件创建（推荐）
zai, err := client.Create()

// 使用配置对象创建
cfg := &config.Config{
    BaseURL: "https://api.example.com/v1",
    APIKey:  "your-api-key",
}
zai := client.New(cfg)

zai := client.New(cfg,
    client.WithTimeout(30*time.Second),
    client.WithHTTPClient(customHTTPClient),
)

resp, err := zai.CreateChatCompletion(ctx, &types.CreateChatCompletionRequest{
    Model: "gpt-3.5-turbo",
    Messages: []types.ChatMessage{
        {Role: "system", Content: "You are a helpful assistant."},
        {Role: "user", Content: "Hello!"},
    },
    Temperature: 0.7,
    MaxTokens:   1000,
})

type CreateChatCompletionResponse struct {
    ID      string                 `json:"id"`
    Object  string                 `json:"object"`
    Created int64                  `json:"created"`
    Model   string                 `json:"model"`
    Choices []ChatCompletionChoice `json:"choices"`
    Usage   *Usage                 `json:"usage,omitempty"`
}

type ChatCompletionChoice struct {
    Index        int            `json:"index"`
    Message      ChatMessage    `json:"message"`
    FinishReason string         `json:"finish_reason"`
}

stream, _, err := zai.CreateChatCompletionStream(ctx, req)
if err != nil {
    // handle error
}
defer stream.Close()

// 手动处理 SSE 流
scanner := bufio.NewScanner(stream)
for scanner.Scan() {
    line := scanner.Text()
    if strings.HasPrefix(line, "data: ") {
        // 解析 SSE 数据
    }
}

err := zai.ProcessChatStream(ctx, req, func(chunk *client.StreamChunk) error {
    for _, choice := range chunk.Choices {
        fmt.Print(choice.Delta.Content)
    }
    return nil
})

resp, err := zai.CollectChatStream(ctx, req)
fmt.Println(resp.Choices[0].Message.Content)

resp, err := zai.CreateChatCompletionVision(ctx, &types.CreateChatCompletionVisionRequest{
    Model: "gpt-4-vision-preview",
    Messages: []types.VisionMessage{
        {
            Role: "user",
            Items: []types.VisionMultimodalContentItem{
                {Type: "text", Text: "描述这张图片"},
                {Type: "image_url", ImageURL: &types.MediaURL{URL: "https://example.com/image.jpg"}},
                {Type: "video_url", VideoURL: &types.MediaURL{URL: "https://example.com/video.mp4"}},
                {Type: "file_url", FileURL: &types.MediaURL{URL: "https://example.com/document.pdf"}},
            },
        },
    },
})

stream, _, err := zai.CreateChatCompletionVisionStream(ctx, req)
defer stream.Close()
io.Copy(os.Stdout, stream)

resp, err := zai.CreateAudioTTS(ctx, &types.CreateAudioTTSRequest{
    Input:          "你好，世界！",
    Voice:          "tongtong",
    Speed:          1.0,
    ResponseFormat: "wav",
    Stream:         false,
})
defer resp.Body.Close()

// resp.Body 包含音频二进制数据
data, _ := io.ReadAll(resp.Body)
os.WriteFile("output.wav", data, 0644)

resp, err := zai.CreateAudioASR(ctx, &types.CreateAudioASRRequest{
    FileBase64: base64EncodedAudio,
})
fmt.Println(resp.Text)

resp, err := zai.CreateImageGeneration(ctx, &types.CreateImageGenerationRequest{
    Prompt: "一只可爱的小猫",
    Size:   "1024x1024",
})

// resp.Data[0].Base64 包含 base64 编码的 PNG 图片
data, _ := base64.StdEncoding.DecodeString(resp.Data[0].Base64)
os.WriteFile("cat.png", data, 0644)

resp, err := zai.CreateImageEdit(ctx, &types.CreateImageEditRequest{
    Prompt: "添加彩虹",
    Image:  base64EncodedImage,
    Size:   "1024x1024",
})

resp, err := zai.CreateImageSearch(ctx, &types.CreateImageSearchRequest{
    Query: "日落 海洋",
    Count: 10,
})

for _, result := range resp.Results {
    fmt.Println(result.OriginalURL)
}

resp, err := zai.CreateVideoGeneration(ctx, &types.CreateVideoGenerationRequest{
    Prompt:    "A cat playing with a ball",
    Quality:   "speed",
    Size:      "1920x1080",
    FPS:       30,
    Duration:  5,
})

// resp.ID 是任务 ID，需要异步查询结果
fmt.Println("Task ID:", resp.ID)
fmt.Println("Task Status:", resp.TaskStatus)

result, err := zai.QueryAsyncResult(ctx, taskID)

switch result.TaskStatus {
case "SUCCESS":
    fmt.Println("Video URL:", result.VideoResult[0].URL)
case "PROCESSING":
    fmt.Println("Still processing...")
case "FAIL":
    fmt.Println("Task failed")
}

type AsyncResultResponse struct {
    ID          string            `json:"id"`
    TaskStatus  string            `json:"task_status"` // PROCESSING, SUCCESS, FAIL
    VideoResult []VideoResultItem `json:"video_result,omitempty"`
    VideoURL    string            `json:"video_url,omitempty"`
    URL         string            `json:"url,omitempty"`
    Video       string            `json:"video,omitempty"`
}

result, err := zai.InvokeFunction(ctx, "web_search", map[string]any{
    "query":       "Golang 教程",
    "num":         5,
    "recency_days": 10,
})

result, err := zai.WebSearch(ctx, &types.SearchFunctionArgs{
    Query:       "Golang 教程",
    Num:         5,
    RecencyDays: 10,
})

result, err := zai.PageReader(ctx, &types.PageReaderFunctionArgs{
    URL: "https://example.com",
})

fmt.Println("标题:", result.Data.Title)
fmt.Println("URL:", result.Data.URL)
fmt.Println("发布时间:", result.Data.PublishedTime)
fmt.Println("HTML:", result.Data.HTML)

import "cnb.cool/S.o/z-ai-sdk-go/server"

zai, _ := client.Create()
srv := server.New(zai, server.WithAddr(":8080"))
srv.Run()

# 聊天补全
curl -X POST http://localhost:8080/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

# 图片生成
curl -X POST http://localhost:8080/api/v1/images/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A beautiful sunset",
    "size": "1024x1024"
  }'

                    ┌─────────────────┐
                    │   Proxy Gateway │
                    │   (WebSocket)   │
                    └────────┬────────┘
                             │
            ┌────────────────┼────────────────┐
            │                │                │
      ┌─────▼─────┐    ┌────▼────┐    ┌─────▼─────┐
      │  Client 1  │    │ Client 2│    │  Client 3  │
      │(本地 API)  │    │(本地API)│    │(本地 API)  │
      └───────────┘    └─────────┘    └───────────┘

# 生产模式（需要认证）
PROXY_API_KEY=your-secret-key proxy-gateway

# 开发模式（无认证）
PROXY_API_KEY= proxy-gateway

PROXY_GATEWAY_URL=wss://gateway.example.com/tunnel \
PROXY_API_KEY=your-secret-key \
PROXY_NODE_ID=node-001 \
proxy-client

# Pool 级统计
curl http://gateway:8090/stats

# Session 列表
curl http://gateway:8090/sessions

# Session 详情（含 Streams）
curl http://gateway:8090/sessions/node-001

resp, err := zai.CreateChatCompletion(ctx, req)
if err != nil {
    if apiErr, ok := err.(*types.APIError); ok {
        fmt.Printf("API error: %d - %s\n", apiErr.StatusCode, apiErr.Message)
    } else {
        fmt.Printf("Other error: %v\n", err)
    }
    return
}

type APIError struct {
    StatusCode int    `json:"status_code"`
    Message    string `json:"message"`
    Code       string `json:"code,omitempty"`
}

{
  "baseUrl": "https://api.example.com/v1",
  "apiKey": "your-api-key",
  "chatId": "optional-chat-id",
  "userId": "optional-user-id"
}

export ZAI_BASE_URL=https://api.example.com/v1
export ZAI_API_KEY=your-api-key