Files
dobotai-platform/internal/weknora/client.go
T
2026-07-20 23:10:08 +08:00

314 lines
9.6 KiB
Go

package weknora
import (
"bufio"
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"time"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
)
var ErrIncompleteStream = errors.New("weknora stream ended without a terminal event")
var ErrEmptyAnswer = errors.New("weknora stream completed with an empty answer")
// AnswerObserver is called with the accumulated full answer content after each
// answer chunk. The observer is purely a notification; its return is ignored.
type AnswerObserver func(fullContent string)
// StreamEvent is a safe, structured representation of a WeKnora streaming event.
// It deliberately does not expose raw Content, Data, or Reference content to
// prevent leaking internal thinking/tool details to external channels.
type StreamEvent struct {
ResponseType string
Done bool
FullAnswer string
ReferenceCount int
ToolName string
}
// StreamObserver is called with a safe StreamEvent for each SSE event.
type StreamObserver func(StreamEvent)
type Client struct {
baseURL string
apiKey string
http *http.Client
}
type AgentChatRequest struct {
Query string `json:"query"`
AgentEnabled bool `json:"agent_enabled"`
AgentID string `json:"agent_id"`
Channel string `json:"channel,omitempty"`
EnableMemory bool `json:"enable_memory,omitempty"`
DisableTitle bool `json:"disable_title,omitempty"`
KnowledgeBaseIDs []string `json:"knowledge_base_ids,omitempty"`
Images []Image `json:"images,omitempty"`
}
type Image struct {
Data string `json:"data"`
}
type ChatResult struct {
RequestID string
Answer string
References []core.Reference
}
func NewClient(baseURL, apiKey string, timeout time.Duration) (*Client, error) {
parsed, err := url.Parse(strings.TrimRight(strings.TrimSpace(baseURL), "/"))
if err != nil || parsed.Scheme == "" || parsed.Host == "" {
return nil, errors.New("invalid WEKNORA_BASE_URL")
}
if strings.TrimSpace(apiKey) == "" {
return nil, errors.New("WEKNORA_API_KEY is required")
}
if timeout <= 0 {
timeout = 120 * time.Second
}
return &Client{baseURL: parsed.String(), apiKey: apiKey, http: &http.Client{Timeout: timeout}}, nil
}
func (c *Client) CreateSession(ctx context.Context, title, description string) (string, error) {
var response struct {
Success bool `json:"success"`
Data struct {
ID string `json:"id"`
} `json:"data"`
}
if err := c.doJSON(ctx, http.MethodPost, "/api/v1/sessions", map[string]string{
"title": title, "description": description,
}, &response); err != nil {
return "", err
}
if !response.Success || strings.TrimSpace(response.Data.ID) == "" {
return "", errors.New("weknora returned an empty session id")
}
return response.Data.ID, nil
}
func (c *Client) AgentChat(ctx context.Context, sessionID string, request AgentChatRequest) (ChatResult, error) {
return c.AgentChatStream(ctx, sessionID, request, nil)
}
func (c *Client) AgentChatStream(ctx context.Context, sessionID string, request AgentChatRequest, observer AnswerObserver) (ChatResult, error) {
return c.agentChat(ctx, sessionID, request, observer, nil)
}
func (c *Client) AgentChatEvents(ctx context.Context, sessionID string, request AgentChatRequest, observer StreamObserver) (ChatResult, error) {
return c.agentChat(ctx, sessionID, request, nil, observer)
}
func (c *Client) agentChat(ctx context.Context, sessionID string, request AgentChatRequest, answerObserver AnswerObserver, eventObserver StreamObserver) (ChatResult, error) {
if strings.TrimSpace(sessionID) == "" || strings.TrimSpace(request.AgentID) == "" || strings.TrimSpace(request.Query) == "" {
return ChatResult{}, errors.New("session id, agent id and query are required")
}
request.AgentEnabled = true
body, err := json.Marshal(request)
if err != nil {
return ChatResult{}, fmt.Errorf("encode agent chat request: %w", err)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/api/v1/agent-chat/"+url.PathEscape(sessionID), bytes.NewReader(body))
if err != nil {
return ChatResult{}, fmt.Errorf("create agent chat request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "text/event-stream")
req.Header.Set("X-API-Key", c.apiKey)
resp, err := c.http.Do(req)
if err != nil {
return ChatResult{}, fmt.Errorf("call weknora agent chat: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
message, _ := io.ReadAll(io.LimitReader(resp.Body, 32<<10))
return ChatResult{}, fmt.Errorf("weknora agent chat returned HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(message)))
}
return parseSSEWithEventObserver(resp.Body, answerObserver, eventObserver)
}
func (c *Client) doJSON(ctx context.Context, method, path string, input, output any) error {
body, err := json.Marshal(input)
if err != nil {
return fmt.Errorf("encode weknora request: %w", err)
}
req, err := http.NewRequestWithContext(ctx, method, c.baseURL+path, bytes.NewReader(body))
if err != nil {
return fmt.Errorf("create weknora request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-API-Key", c.apiKey)
resp, err := c.http.Do(req)
if err != nil {
return fmt.Errorf("call weknora: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
message, _ := io.ReadAll(io.LimitReader(resp.Body, 32<<10))
return fmt.Errorf("weknora returned HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(message)))
}
if err := json.NewDecoder(io.LimitReader(resp.Body, 2<<20)).Decode(output); err != nil {
return fmt.Errorf("decode weknora response: %w", err)
}
return nil
}
func parseSSE(reader io.Reader) (ChatResult, error) {
return parseSSEWithEventObserver(reader, nil, nil)
}
func parseSSEWithObserver(reader io.Reader, observer AnswerObserver) (ChatResult, error) {
return parseSSEWithEventObserver(reader, observer, nil)
}
func parseSSEWithEventObserver(reader io.Reader, answerObserver AnswerObserver, eventObserver StreamObserver) (ChatResult, error) {
scanner := bufio.NewScanner(reader)
scanner.Buffer(make([]byte, 64<<10), 2<<20)
var result ChatResult
var dataLines []string
terminal := false
notify := func(e StreamEvent) {
if eventObserver != nil {
eventObserver(e)
}
}
flush := func() error {
if len(dataLines) == 0 {
return nil
}
raw := strings.Join(dataLines, "\n")
dataLines = dataLines[:0]
var event struct {
ID string `json:"id"`
ResponseType string `json:"response_type"`
Content string `json:"content"`
Done bool `json:"done"`
KnowledgeReferences []core.Reference `json:"knowledge_references"`
Data json.RawMessage `json:"data"`
}
if err := json.Unmarshal([]byte(raw), &event); err != nil {
return fmt.Errorf("decode weknora SSE event: %w", err)
}
if event.ID != "" {
result.RequestID = event.ID
}
switch event.ResponseType {
case "references":
result.References = append([]core.Reference(nil), event.KnowledgeReferences...)
notify(StreamEvent{
ResponseType: "references",
ReferenceCount: len(event.KnowledgeReferences),
})
case "answer":
hasContent := strings.TrimSpace(event.Content) != ""
result.Answer += event.Content
if hasContent && answerObserver != nil {
answerObserver(result.Answer)
}
notify(StreamEvent{
ResponseType: "answer",
Done: event.Done,
FullAnswer: result.Answer,
})
if event.Done {
terminal = true
}
case "error":
if event.Content == "" {
event.Content = "weknora returned an unspecified error"
}
// Notify with error type but no content, then return the error
notify(StreamEvent{
ResponseType: "error",
Done: true,
})
return errors.New(event.Content)
case "thinking", "reflection":
notify(StreamEvent{
ResponseType: event.ResponseType,
Done: event.Done,
})
case "tool_call", "tool_result":
toolName := extractToolName(event.Data)
notify(StreamEvent{
ResponseType: event.ResponseType,
Done: event.Done,
ToolName: toolName,
})
case "complete":
if event.Done {
terminal = true
}
notify(StreamEvent{
ResponseType: "complete",
Done: event.Done,
})
default:
notify(StreamEvent{
ResponseType: event.ResponseType,
Done: event.Done,
})
}
return nil
}
for scanner.Scan() {
line := scanner.Text()
if line == "" {
if err := flush(); err != nil {
return ChatResult{}, err
}
continue
}
if strings.HasPrefix(line, "data:") {
dataLines = append(dataLines, strings.TrimSpace(strings.TrimPrefix(line, "data:")))
}
}
if err := scanner.Err(); err != nil {
return ChatResult{}, fmt.Errorf("read weknora SSE stream: %w", err)
}
if err := flush(); err != nil {
return ChatResult{}, err
}
if !terminal {
return ChatResult{}, ErrIncompleteStream
}
if strings.TrimSpace(result.Answer) == "" {
return ChatResult{}, ErrEmptyAnswer
}
return result, nil
}
// extractToolName extracts the tool_name string from a JSON Data field.
// The Data may be any JSON shape; we look for the "tool_name" key and return
// its string value. Returns empty string if not found or not a string.
func extractToolName(data json.RawMessage) string {
if len(data) == 0 {
return ""
}
var m map[string]json.RawMessage
if err := json.Unmarshal(data, &m); err != nil {
return ""
}
v, ok := m["tool_name"]
if !ok {
return ""
}
var s string
if err := json.Unmarshal(v, &s); err != nil {
return ""
}
return s
}