Aska
24d5924cee
- 新增 model/stream.go：StreamKind(text/thinking/tool_call 各 start/delta/end + tool_execution)
+ StreamEvent{Kind,Delta,Index,ID}。
- ChatStream 签名 onChunk func(delta string)→onEvent func(StreamEvent)；loop OnStream 同改；
streamStep 转发结构化事件。
- openai：text_delta + text_start/text_end（正文三段式）；anthropic：文本块 text_*/tool_call_*
按块 Index（content_block_stop 分支）真分段；fallback：有事件即交付。
- ws_hub：wsEvent 壳补 turnId/seq；新增 broadcastStream；streamChat 每帧打 turnId+seq；
stream.go 把事件 publish 到 bus ws.stream。
- ws_bridge：streamEventData 映射 text_*→message.start/delta/end、thinking_*→thinking.*、
tool_call_*→tool_call.*、tool_execution_update→tool_execution.update，未知回退 stream_chunk。
- 前端 ws.ts：解析 message.start/delta/end、thinking.start/delta/end(pendingThinking)、
tool_call.start/end→addTool、tool_execution.update；保留旧 stream_chunk/thinking/tool_used 兼容；
types.ts 补 turnId/seq。Docs/api-client.md 增 §3.1 v0.4。
已知限制（注释/文档标注）：turnId 在 OnStream→bus→relay 路径暂为空（StreamEvent 无 turnId 字段，
bus ws.stream 载荷不带 turn）；OpenAI adapter 未解析 tool_call 段；thinking 段两 adapter 暂不发；
tool_execution.update 是保留项（随工具循环钩子后置）。go build/vet/test + 前端 tsc 全绿。
94 lines
2.8 KiB
Go
94 lines
2.8 KiB
Go
package model
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"git.yeij.top/AskaEth/Cyrene_v2/internal/config"
|
|
)
|
|
|
|
// Step binds a model name to an Adapter for one entry in a fallback chain. An
|
|
// empty Model keeps the incoming Request.Model.
|
|
type Step struct {
|
|
Model string
|
|
Adapter Adapter
|
|
}
|
|
|
|
// Chain is an Adapter that tries its steps in order and returns the first
|
|
// successful response. It implements Adapter, so it can be used anywhere a
|
|
// single provider is expected.
|
|
type Chain struct {
|
|
steps []Step
|
|
}
|
|
|
|
// NewChain builds a fallback chain from the given steps.
|
|
func NewChain(steps ...Step) *Chain {
|
|
return &Chain{steps: steps}
|
|
}
|
|
|
|
// NewOpenAIChatChain builds a fallback chain from a single supplier config: the
|
|
// primary model first, then cfg.Fallback (when set and distinct), both served
|
|
// by an OpenAIChatAdapter against the same OpenAI-compatible endpoint. It
|
|
// delegates to the provider-aware builder so the OpenAI path and the factory stay
|
|
// in sync. It returns ErrNoModel when no base URL or primary model is configured.
|
|
func NewOpenAIChatChain(cfg config.LLMConfig, opts ...OpenAIOption) (*Chain, error) {
|
|
return newOpenAIChain(cfg, opts...)
|
|
}
|
|
|
|
// Name returns the chain identifier.
|
|
func (c *Chain) Name() string { return "fallback" }
|
|
|
|
// Chat tries each step in order and returns the first success. If every step
|
|
// fails, the last error is returned wrapped as ErrUpstream.
|
|
func (c *Chain) Chat(ctx context.Context, req Request, opts Options) (Response, error) {
|
|
if len(c.steps) == 0 {
|
|
return Response{}, ErrNoSteps
|
|
}
|
|
var lastErr error
|
|
for _, s := range c.steps {
|
|
stepReq := req
|
|
if s.Model != "" {
|
|
stepReq.Model = s.Model
|
|
}
|
|
resp, err := s.Adapter.Chat(ctx, stepReq, opts)
|
|
if err == nil {
|
|
return resp, nil
|
|
}
|
|
lastErr = err
|
|
}
|
|
return Response{}, fmt.Errorf("model: %w: %v", ErrUpstream, lastErr)
|
|
}
|
|
|
|
// ChatStream tries each step in order. If a step fails before delivering any
|
|
// event, the chain moves to the next step; once a step has delivered output it
|
|
// is committed, so a mid-stream failure surfaces as an error rather than mixing
|
|
// content across providers.
|
|
func (c *Chain) ChatStream(ctx context.Context, req Request, onEvent func(StreamEvent)) (Response, error) {
|
|
if len(c.steps) == 0 {
|
|
return Response{}, ErrNoSteps
|
|
}
|
|
var lastErr error
|
|
for _, s := range c.steps {
|
|
stepReq := req
|
|
if s.Model != "" {
|
|
stepReq.Model = s.Model
|
|
}
|
|
delivered := false
|
|
wrapped := func(ev StreamEvent) {
|
|
delivered = true
|
|
if onEvent != nil {
|
|
onEvent(ev)
|
|
}
|
|
}
|
|
resp, err := s.Adapter.ChatStream(ctx, stepReq, wrapped)
|
|
if err == nil {
|
|
return resp, nil
|
|
}
|
|
if delivered {
|
|
return Response{}, fmt.Errorf("model: %w: stream step %q failed after partial output: %v", ErrUpstream, s.Model, err)
|
|
}
|
|
lastErr = err
|
|
}
|
|
return Response{}, fmt.Errorf("model: %w: %v", ErrUpstream, lastErr)
|
|
}
|