refactor(cli): command-surface rename — session ask / doc fetch / doc create / doc delete --all

Three command renames consolidate the v0.7 verb table:

- `weknora agent invoke` → `weknora session ask --agent <id>`.
  Server route POST /sessions/{session_id}/agent-qa is session-
  anchored, so the verb moves with it. `weknora agent` subtree keeps
  CRUD only (list / view / create / edit / delete / status / check).
  SDK call (AgentQAStreamWithRequest) preserved verbatim; only the
  command surface + flag layout move.

- `weknora doc upload` split into three commands:
  - `weknora doc upload <file>`  — local file (only).
  - `weknora doc fetch <url>`    — server-side remote fetch (was
    `upload --from-url`). URL-only flags (--title / --file-type /
    --tag-id) move with the verb.
  - `weknora doc create --text`  — direct text knowledge entry via
    server CreateManualKnowledge.

- `weknora kb empty <id>` → `weknora doc delete --all --kb=<id>`.
  Atomic server ClearKnowledgeBaseContents (no list-then-delete
  race). Same exit-10 -y/--yes guard as other destructive verbs;
  unified through the extended ConfirmDestructive helper.

Parent commands (agent, kb, doc, chunk, session, auth, profile,
search) lose their explicit Args:NoArgs + Run:cmd.Help so the
unknown-subcommand guard fires correctly — `weknora agent invoke
ag_x q` now emits the typed input.unknown_subcommand envelope with
detail.available[] instead of cobra's free-form exit-2 prose.

Spec: docs/superpowers/specs/2026-05-20-weknora-cli-v0.7-design.md §3.4 / §10.7
This commit is contained in:
nullkey
2026-05-21 18:42:27 +08:00
committed by lyingbug
parent ad150c7126
commit a2e368b1e8
20 changed files with 1866 additions and 1377 deletions
+275
View File
@@ -0,0 +1,275 @@
package sessioncmd
import (
"context"
"fmt"
"io"
"strings"
"github.com/spf13/cobra"
"github.com/Tencent/WeKnora/cli/internal/cmdutil"
"github.com/Tencent/WeKnora/cli/internal/format"
"github.com/Tencent/WeKnora/cli/internal/iostreams"
"github.com/Tencent/WeKnora/cli/internal/output"
"github.com/Tencent/WeKnora/cli/internal/sse"
sdk "github.com/Tencent/WeKnora/client"
)
// sessionAskFields enumerates the NDJSON init-event fields surfaced for
// `--format json` / `--format ndjson` discovery on `session ask`. Reflects
// the InitEvent head line + the raw SDK agent event vocabulary (§5).
var sessionAskFields = []string{
"session_id", "agent_id",
// SDK event fields (pass-through): response_type, content, done,
// knowledge_references, tool_call_id, tool_result
}
// AskOptions captures `session ask` flag state.
type AskOptions struct {
AgentID string
Query string
SessionID string // --session: continue an existing session (skip auto-create)
}
// AskService is the narrow SDK surface this command depends on.
//
// CreateSession is called when --session is omitted — sessions are
// agent-agnostic at creation (verified against
// internal/handler/session/handler.go CreateSession, which only persists
// {title, description}). The agent ID is supplied per-request via
// AgentQARequest.AgentID, so the same session can be reused across
// agent / KB-chat invocations.
type AskService interface {
CreateSession(ctx context.Context, req *sdk.CreateSessionRequest) (*sdk.Session, error)
AgentQAStreamWithRequest(ctx context.Context, sessionID string, req *sdk.AgentQARequest, cb sdk.AgentEventCallback) error
}
// NewCmdAsk builds `weknora session ask --agent <agent-id> "<text>"`.
func NewCmdAsk(f *cmdutil.Factory) *cobra.Command {
opts := &AskOptions{}
cmd := &cobra.Command{
Use: `ask "<text>"`,
Short: "Ask a server-side agent in a session context",
Long: `Invoke a server-side agent within a session. If --session is omitted,
a new session is auto-created and its id is reported in the output for
the caller to thread follow-ups.
AI agents: this is the primary entrypoint for invoking custom agents.
The 'weknora agent' subtree handles CRUD only (list / view / create /
edit / delete / status / check).
Modes:
TTY (human format, default): live answer streaming + tool-trace footer
--format json / --format ndjson / pipe: NDJSON event stream — one init line
at head (session_id, agent_id), then raw SDK
agent events verbatim. Both json and ndjson
flags produce the same NDJSON stream (§5).`,
Example: ` weknora session ask --agent ag_x "Summarize Q3 sales"
weknora session ask --session sess_x --agent ag_x "Follow-up question"
weknora session ask --agent ag_x "Multi-step task" --format ndjson`,
Args: cobra.ExactArgs(1),
RunE: func(c *cobra.Command, args []string) error {
fopts, err := cmdutil.CheckFormatFlag(c)
if err != nil {
return err
}
fopts.ResolveDefault(iostreams.IO.IsStdoutTTY())
opts.Query = strings.TrimSpace(args[0])
cli, err := f.Client()
if err != nil {
return err
}
return runAsk(c.Context(), opts, fopts, cli)
},
}
cmd.Flags().StringVarP(&opts.AgentID, "agent", "a", "", "Agent ID to invoke (required)")
_ = cmd.MarkFlagRequired("agent")
cmd.Flags().StringVar(&opts.SessionID, "session", "", "Continue an existing chat session (skip auto-create)")
cmdutil.AddFormatFlag(cmd, sessionAskFields...)
cmdutil.SetAgentHelp(cmd, cmdutil.AgentHelp{
UsedFor: "Invoke a custom agent in a session context. Produces an NDJSON event stream: init line (session_id, agent_id) then raw SDK agent events. Use --format json or --format ndjson.",
RequiredFlags: []string{"--agent"},
Examples: []string{
`weknora session ask --agent ag_x "Summarize Q3 sales" --format json`,
`weknora session ask --session sess_x --agent ag_x "Follow-up question" --format json`,
},
Output: "NDJSON stream: {type:init, session_id, agent_id} then SDK agent events (response_type, content, done, knowledge_references, ...)",
})
return cmd
}
func runAsk(ctx context.Context, opts *AskOptions, fopts *cmdutil.FormatOptions, svc AskService) error {
if opts.Query == "" {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument, "query argument cannot be empty")
}
if opts.AgentID == "" {
return cmdutil.NewError(cmdutil.CodeInputInvalidArgument, "agent-id argument cannot be empty")
}
if svc == nil {
return cmdutil.NewError(cmdutil.CodeServerError, "session ask: no SDK client available")
}
// Streaming commands route --format json AND --format ndjson to the
// NDJSON event-stream path. A buffered envelope makes no sense for a
// streaming command (§5). Only --format human (or TTY default) uses the
// live renderer.
ndjsonMode := fopts != nil && (fopts.Mode == cmdutil.FormatJSON || fopts.Mode == cmdutil.FormatNDJSON)
sessionID := opts.SessionID
autoCreated := false
if sessionID == "" {
sess, err := svc.CreateSession(ctx, &sdk.CreateSessionRequest{Title: "weknora session ask"})
if err != nil {
if cmdutil.IsCancelled(ctx, err) {
return cmdutil.Wrapf(cmdutil.CodeOperationCancelled, err, "session ask cancelled")
}
code := cmdutil.ClassifyHTTPError(err)
if code == cmdutil.CodeNetworkError || code == cmdutil.CodeServerError {
code = cmdutil.CodeSessionCreateFailed
}
return cmdutil.Wrapf(code, err, "create chat session")
}
sessionID = sess.ID
autoCreated = true
}
if ndjsonMode {
return runAskNDJSON(ctx, opts, sessionID, svc)
}
// Surface auto-created session id up-front so a ^C mid-stream still
// leaves a recoverable pointer. Skipped in NDJSON mode (it appears in
// the init event).
if autoCreated {
fmt.Fprintf(iostreams.IO.Err, "session: %s (use --session to continue)\n", sessionID)
}
return runAskHuman(ctx, opts, sessionID, autoCreated, svc)
}
// runAskNDJSON handles --format json and --format ndjson paths.
// Emits a CLI init event at stream head, then passes every SDK agent event
// through verbatim as NDJSON lines. No buffering (§5).
func runAskNDJSON(ctx context.Context, opts *AskOptions, sessionID string, svc AskService) error {
w := iostreams.IO.Out
// 1. Inject the CLI-managed init event at the head of the stream (§5.3).
// Carries session pointer + agent id callers need for follow-up threading.
initEv := output.InitEvent{
SessionID: sessionID,
AgentID: opts.AgentID,
Profile: cmdutil.GetProfile(),
}
if err := output.EmitInit(w, initEv); err != nil {
return err
}
// 2. Open SDK stream and pass each agent event through as a bare NDJSON line.
req := &sdk.AgentQARequest{
Query: opts.Query,
AgentEnabled: true,
AgentID: opts.AgentID,
Channel: "api",
}
cb := func(r *sdk.AgentStreamResponse) error {
return output.EmitSDKEvent(w, r)
}
if err := svc.AgentQAStreamWithRequest(ctx, sessionID, req, cb); err != nil {
if cmdutil.IsCancelled(ctx, err) {
return cmdutil.Wrapf(cmdutil.CodeOperationCancelled, err, "session ask cancelled")
}
return cmdutil.WrapHTTP(err, "agent-chat stream")
}
return nil
}
// runAskHuman handles the TTY / human-text path. Streams answer fragments
// live on TTY; accumulates then renders on non-TTY pipes.
func runAskHuman(ctx context.Context, opts *AskOptions, sessionID string, autoCreated bool, svc AskService) error {
// Stream mode requires an interactive stdout.
streamMode := iostreams.IO.IsStdoutTTY()
req := &sdk.AgentQARequest{
Query: opts.Query,
AgentEnabled: true,
AgentID: opts.AgentID,
Channel: "api",
}
acc := &sse.AgentAccumulator{}
cb := func(r *sdk.AgentStreamResponse) error {
if streamMode && r != nil && r.ResponseType == sdk.AgentResponseTypeAnswer && r.Content != "" {
_, _ = iostreams.IO.Out.Write([]byte(r.Content))
}
acc.Append(r)
return nil
}
streamErr := svc.AgentQAStreamWithRequest(ctx, sessionID, req, cb)
if streamErr != nil {
if autoCreated {
fmt.Fprintf(iostreams.IO.Err, "session: %s (resume with --session %s)\n", sessionID, sessionID)
}
if cmdutil.IsCancelled(ctx, streamErr) {
return cmdutil.Wrapf(cmdutil.CodeOperationCancelled, streamErr, "session ask cancelled")
}
if acc.Answer() != "" && !acc.Done() {
return cmdutil.Wrapf(cmdutil.CodeSSEStreamAborted, streamErr, "stream aborted before completion")
}
return cmdutil.WrapHTTP(streamErr, "agent-chat stream")
}
// Server closed cleanly but never sent a Done event — treat as aborted
// so agents don't silently emit a truncated answer as ok=true.
if !acc.Done() {
return cmdutil.NewError(cmdutil.CodeSSEStreamAborted, "stream ended without a terminal event")
}
answer := acc.Answer()
out := iostreams.IO.Out
if streamMode {
if !strings.HasSuffix(answer, "\n") {
fmt.Fprintln(out)
}
} else {
fmt.Fprint(out, answer)
if !strings.HasSuffix(answer, "\n") {
fmt.Fprintln(out)
}
}
renderAskToolTrace(out, acc.ToolEvents)
format.WriteReferences(out, acc.References)
return nil
}
// renderAskToolTrace prints a compact tool-event footer in human mode.
// Skipped when the agent emitted no tool events — silent beats an empty
// banner.
func renderAskToolTrace(w io.Writer, events []sse.AgentToolEvent) {
if len(events) == 0 {
return
}
fmt.Fprintln(w)
fmt.Fprintln(w, "──── Tool trace ────")
for i, e := range events {
fmt.Fprintf(w, "[%d] %s", i+1, e.Kind)
if e.Result != "" {
fmt.Fprintf(w, " %s", truncateAskInline(e.Result, 80))
}
fmt.Fprintln(w)
}
}
// truncateAskInline shrinks a multi-line result to a single line + ellipsis
// for the human tool-trace footer.
func truncateAskInline(s string, maxLen int) string {
s = strings.ReplaceAll(s, "\n", " ")
if len(s) <= maxLen {
return s
}
return s[:maxLen-1] + "…"
}
// compile-time check: production SDK client satisfies AskService.
var _ AskService = (*sdk.Client)(nil)
+465
View File
@@ -0,0 +1,465 @@
package sessioncmd
import (
"bytes"
"context"
"encoding/json"
"errors"
"strings"
"testing"
"github.com/Tencent/WeKnora/cli/internal/cmdutil"
"github.com/Tencent/WeKnora/cli/internal/iostreams"
sdk "github.com/Tencent/WeKnora/client"
)
// scriptedAskSvc serves a canned stream of agent events to runAsk.
type scriptedAskSvc struct {
createResp *sdk.Session
createErr error
events []*sdk.AgentStreamResponse
streamErr error
got struct {
sessionID string
req *sdk.AgentQARequest
}
}
func (s *scriptedAskSvc) CreateSession(_ context.Context, req *sdk.CreateSessionRequest) (*sdk.Session, error) {
if s.createResp == nil && s.createErr == nil {
return &sdk.Session{ID: "sess_auto", Title: req.Title}, nil
}
return s.createResp, s.createErr
}
func (s *scriptedAskSvc) AgentQAStreamWithRequest(_ context.Context, sessionID string, req *sdk.AgentQARequest, cb sdk.AgentEventCallback) error {
s.got.sessionID = sessionID
s.got.req = req
for _, e := range s.events {
if err := cb(e); err != nil {
return err
}
}
return s.streamErr
}
func answerEvent(content string) *sdk.AgentStreamResponse {
return &sdk.AgentStreamResponse{ResponseType: sdk.AgentResponseTypeAnswer, Content: content}
}
func doneEvent() *sdk.AgentStreamResponse {
return &sdk.AgentStreamResponse{ResponseType: sdk.AgentResponseTypeAnswer, Done: true}
}
func toolCallEvent(id, name string) *sdk.AgentStreamResponse {
return &sdk.AgentStreamResponse{
ResponseType: sdk.AgentResponseTypeToolCall,
ID: id,
Content: name,
}
}
func referencesEvent(refs []*sdk.SearchResult) *sdk.AgentStreamResponse {
return &sdk.AgentStreamResponse{
ResponseType: sdk.AgentResponseTypeReferences,
KnowledgeReferences: refs,
}
}
// textOpts returns a FormatOptions configured for the text (human) render
// path — the most common shape under test.
func textOpts() *cmdutil.FormatOptions {
return &cmdutil.FormatOptions{Mode: cmdutil.FormatHuman}
}
// ndjsonOpts returns a FormatOptions for the NDJSON event-stream path.
// --format json routes here too (§5).
func ndjsonOpts() *cmdutil.FormatOptions {
return &cmdutil.FormatOptions{Mode: cmdutil.FormatNDJSON}
}
// jsonOpts returns a FormatOptions configured for the JSON path.
// In v0.7 --format json routes to the NDJSON stream path for streaming commands.
func jsonOpts() *cmdutil.FormatOptions {
return &cmdutil.FormatOptions{Mode: cmdutil.FormatJSON}
}
// TestSessionAsk_NDJSON_FirstLineIsInit verifies that the NDJSON path (--format json)
// always injects an "init" line first, carrying session_id and agent_id.
func TestSessionAsk_NDJSON_FirstLineIsInit(t *testing.T) {
out, errBuf := iostreams.SetForTest(t)
svc := &scriptedAskSvc{
events: []*sdk.AgentStreamResponse{
answerEvent("answer"),
doneEvent(),
},
}
opts := &AskOptions{AgentID: "ag_x", Query: "ping"}
if err := runAsk(context.Background(), opts, jsonOpts(), svc); err != nil {
t.Fatalf("runAsk: %v", err)
}
// NDJSON mode must NOT print the session hint to stderr.
if errBuf.Len() != 0 {
t.Errorf("expected empty stderr in NDJSON mode, got %q", errBuf.String())
}
lines := strings.Split(strings.TrimRight(out.String(), "\n"), "\n")
if len(lines) == 0 {
t.Fatal("no output")
}
var first struct {
Type string `json:"type"`
SessionID string `json:"session_id"`
AgentID string `json:"agent_id"`
}
if err := json.Unmarshal([]byte(lines[0]), &first); err != nil {
t.Fatalf("first line not JSON: %v\n %s", err, lines[0])
}
if first.Type != "init" {
t.Errorf("first line type: got %q, want init", first.Type)
}
if first.SessionID != "sess_auto" {
t.Errorf("init.session_id: got %q, want sess_auto", first.SessionID)
}
if first.AgentID != "ag_x" {
t.Errorf("init.agent_id: got %q, want ag_x", first.AgentID)
}
}
// TestSessionAsk_NDJSON_PassthroughEvents verifies init + N SDK events = N+1 total lines.
func TestSessionAsk_NDJSON_PassthroughEvents(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &scriptedAskSvc{
events: []*sdk.AgentStreamResponse{
answerEvent("hello"),
doneEvent(),
},
}
opts := &AskOptions{AgentID: "ag_x", Query: "hi"}
if err := runAsk(context.Background(), opts, jsonOpts(), svc); err != nil {
t.Fatalf("runAsk: %v", err)
}
lines := strings.Split(strings.TrimRight(out.String(), "\n"), "\n")
// 1 init + 2 SDK events = 3 lines.
if len(lines) != 3 {
t.Fatalf("got %d lines, want 3:\n%s", len(lines), out.String())
}
// Each must be valid JSON.
for i, line := range lines {
var obj map[string]any
if err := json.Unmarshal([]byte(line), &obj); err != nil {
t.Errorf("line %d not valid JSON: %v\n %s", i+1, err, line)
}
}
}
// TestSessionAsk_NDJSON_JSONEqualsNDJSON verifies that --format json and --format ndjson
// produce identical NDJSON streams for session ask (§5).
func TestSessionAsk_NDJSON_JSONEqualsNDJSON(t *testing.T) {
events := []*sdk.AgentStreamResponse{
answerEvent("hello"),
doneEvent(),
}
runWith := func(mode cmdutil.FormatMode) string {
out, _ := iostreams.SetForTest(t)
svc := &scriptedAskSvc{events: events}
opts := &AskOptions{AgentID: "ag_x", Query: "q"}
fopts := &cmdutil.FormatOptions{Mode: mode}
if err := runAsk(context.Background(), opts, fopts, svc); err != nil {
t.Fatalf("runAsk(%s): %v", mode, err)
}
return out.String()
}
jsonOut := runWith(cmdutil.FormatJSON)
ndjsonOut := runWith(cmdutil.FormatNDJSON)
if jsonOut != ndjsonOut {
t.Errorf("--format json and --format ndjson differ:\n json: %q\n ndjson: %q", jsonOut, ndjsonOut)
}
}
// TestSessionAsk_AutoCreatedSessionID_PassedAsAgentRequest checks the session id
// flows from auto-create through to the SDK stream call.
func TestSessionAsk_AutoCreatedSessionID_PassedAsAgentRequest(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &scriptedAskSvc{events: []*sdk.AgentStreamResponse{doneEvent()}}
opts := &AskOptions{AgentID: "ag_42", Query: "x"}
if err := runAsk(context.Background(), opts, ndjsonOpts(), svc); err != nil {
t.Fatalf("runAsk: %v", err)
}
if svc.got.sessionID != "sess_auto" {
t.Errorf("agent-chat got sessionID=%q, want sess_auto", svc.got.sessionID)
}
if svc.got.req == nil || svc.got.req.AgentID != "ag_42" {
t.Errorf("AgentID not forwarded: %+v", svc.got.req)
}
if !svc.got.req.AgentEnabled {
t.Error("AgentEnabled must be true for session ask")
}
}
func TestSessionAsk_ExistingSessionID_SkipsCreate(t *testing.T) {
_, _ = iostreams.SetForTest(t)
created := false
svc := &scriptedAskSvc{events: []*sdk.AgentStreamResponse{doneEvent()}}
// Wrap CreateSession to detect call.
svc.createResp = &sdk.Session{ID: "should_not_be_used"}
wrapped := &createSessionTracker{AskService: svc, called: &created}
opts := &AskOptions{AgentID: "ag", Query: "x", SessionID: "sess_existing"}
if err := runAsk(context.Background(), opts, ndjsonOpts(), wrapped); err != nil {
t.Fatalf("runAsk: %v", err)
}
if created {
t.Error("CreateSession should not be called when --session is set")
}
if svc.got.sessionID != "sess_existing" {
t.Errorf("agent-chat got sessionID=%q, want sess_existing", svc.got.sessionID)
}
}
type createSessionTracker struct {
AskService
called *bool
}
func (c *createSessionTracker) CreateSession(ctx context.Context, req *sdk.CreateSessionRequest) (*sdk.Session, error) {
*c.called = true
return c.AskService.CreateSession(ctx, req)
}
// TestSessionAsk_EmptyQuery_Rejected checks validation fires before any SDK call.
func TestSessionAsk_EmptyQuery_Rejected(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &scriptedAskSvc{}
opts := &AskOptions{AgentID: "ag", Query: ""}
err := runAsk(context.Background(), opts, textOpts(), svc)
if err == nil {
t.Fatal("expected input.invalid_argument, got nil")
}
var typed *cmdutil.Error
if !errors.As(err, &typed) || typed.Code != cmdutil.CodeInputInvalidArgument {
t.Errorf("expected input.invalid_argument, got %v", err)
}
}
// TestSessionAsk_StreamAbortBeforeDone_MapsToSSEStreamAborted uses the human path
// because the NDJSON path does not buffer/validate Done events.
func TestSessionAsk_StreamAbortBeforeDone_MapsToSSEStreamAborted(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &scriptedAskSvc{
events: []*sdk.AgentStreamResponse{
answerEvent("partial"),
},
streamErr: errors.New("connection reset"),
}
opts := &AskOptions{AgentID: "ag", Query: "x"}
// Human path (textOpts) validates Done; NDJSON path does not buffer.
err := runAsk(context.Background(), opts, textOpts(), svc)
if err == nil {
t.Fatal("expected stream-aborted error")
}
var typed *cmdutil.Error
if !errors.As(err, &typed) || typed.Code != cmdutil.CodeSSEStreamAborted {
t.Errorf("expected local.sse_stream_aborted, got %v", err)
}
}
// TestSessionAsk_NoDoneEvent_MapsToSSEStreamAborted uses the human path
// because the NDJSON path does not validate Done events.
func TestSessionAsk_NoDoneEvent_MapsToSSEStreamAborted(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &scriptedAskSvc{events: []*sdk.AgentStreamResponse{answerEvent("incomplete")}}
opts := &AskOptions{AgentID: "ag", Query: "x"}
err := runAsk(context.Background(), opts, textOpts(), svc)
if err == nil {
t.Fatal("expected stream-aborted error")
}
var typed *cmdutil.Error
if !errors.As(err, &typed) || typed.Code != cmdutil.CodeSSEStreamAborted {
t.Errorf("expected local.sse_stream_aborted, got %v", err)
}
}
func TestSessionAsk_CreateSessionFails_MapsToSessionCreateFailed(t *testing.T) {
_, _ = iostreams.SetForTest(t)
svc := &scriptedAskSvc{createErr: errors.New("connection refused")}
opts := &AskOptions{AgentID: "ag", Query: "x"}
err := runAsk(context.Background(), opts, textOpts(), svc)
if err == nil {
t.Fatal("expected session_create_failed")
}
var typed *cmdutil.Error
if !errors.As(err, &typed) || typed.Code != cmdutil.CodeSessionCreateFailed {
t.Errorf("expected server.session_create_failed, got %v", err)
}
}
func TestSessionAsk_Cancellation_MapsToOperationCancelled(t *testing.T) {
_, _ = iostreams.SetForTest(t)
ctx, cancel := context.WithCancel(context.Background())
cancel() // pre-cancel
svc := &scriptedAskSvc{streamErr: context.Canceled}
opts := &AskOptions{AgentID: "ag", Query: "x"}
// NDJSON path also handles cancellation correctly.
err := runAsk(ctx, opts, ndjsonOpts(), svc)
if err == nil {
t.Fatal("expected operation.cancelled")
}
var typed *cmdutil.Error
if !errors.As(err, &typed) || typed.Code != cmdutil.CodeOperationCancelled {
t.Errorf("expected operation.cancelled, got %v", err)
}
}
// Sanity: human-mode output writes the answer body and a tool-trace footer.
func TestSessionAsk_Human_Accumulate_PrintsAnswerAndFooter(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &scriptedAskSvc{events: []*sdk.AgentStreamResponse{
answerEvent("hello"),
toolCallEvent("c1", "knowledge_search"),
doneEvent(),
}}
opts := &AskOptions{AgentID: "ag", Query: "x"}
if err := runAsk(context.Background(), opts, textOpts(), svc); err != nil {
t.Fatalf("runAsk: %v", err)
}
got := out.String()
if !strings.Contains(got, "hello") {
t.Errorf("answer body missing: %q", got)
}
if !strings.Contains(got, "Tool trace") {
t.Errorf("tool trace footer missing: %q", got)
}
}
// TestSessionAsk_FormatNDJSON_PassthroughsSDKEvents verifies:
// 1 init line + N SDK events = N+1 total lines; first is init, rest are SDK events.
func TestSessionAsk_FormatNDJSON_PassthroughsSDKEvents(t *testing.T) {
// Fake stream emits 3 events: tool_call, answer, done.
// With the init injection, total output is 4 lines (1 init + 3 SDK events).
svc := &scriptedAskSvc{
events: []*sdk.AgentStreamResponse{
toolCallEvent("call_1", "knowledge_search"),
answerEvent("hello"),
doneEvent(),
},
}
out, _ := iostreams.SetForTest(t)
opts := &AskOptions{AgentID: "ag_x", Query: "hi"}
fopts := &cmdutil.FormatOptions{Mode: cmdutil.FormatNDJSON}
if err := runAsk(context.Background(), opts, fopts, svc); err != nil {
t.Fatalf("runAsk: %v", err)
}
lines := strings.Split(strings.TrimRight(out.String(), "\n"), "\n")
// 1 init + 3 SDK events = 4 lines.
if len(lines) != 4 {
t.Fatalf("got %d lines, want 4:\n%s", len(lines), out.String())
}
// Each line must be valid JSON.
for i, line := range lines {
var obj map[string]any
if err := json.Unmarshal([]byte(line), &obj); err != nil {
t.Fatalf("line %d not valid JSON: %v\n %s", i+1, err, line)
}
}
// First line: CLI-injected init event.
var initLine map[string]any
if err := json.Unmarshal([]byte(lines[0]), &initLine); err != nil {
t.Fatalf("line 1 (init) not JSON: %v", err)
}
if initLine["type"] != "init" {
t.Errorf("first line type=%v, want init", initLine["type"])
}
if initLine["agent_id"] != "ag_x" {
t.Errorf("first line agent_id=%v, want ag_x", initLine["agent_id"])
}
// Second line: tool_call event (SDK passthrough).
var second map[string]any
if err := json.Unmarshal([]byte(lines[1]), &second); err != nil {
t.Fatalf("line 2 not JSON: %v", err)
}
if second["response_type"] != string(sdk.AgentResponseTypeToolCall) {
t.Errorf("second event response_type=%v, want %s", second["response_type"], sdk.AgentResponseTypeToolCall)
}
// Third line: answer event.
var third map[string]any
if err := json.Unmarshal([]byte(lines[2]), &third); err != nil {
t.Fatalf("line 3 not JSON: %v", err)
}
if third["response_type"] != string(sdk.AgentResponseTypeAnswer) {
t.Errorf("third event response_type=%v, want %s", third["response_type"], sdk.AgentResponseTypeAnswer)
}
// Fourth line: done event.
var fourth map[string]any
if err := json.Unmarshal([]byte(lines[3]), &fourth); err != nil {
t.Fatalf("line 4 not JSON: %v", err)
}
if fourth["done"] != true {
t.Errorf("fourth event done=%v, want true", fourth["done"])
}
}
func TestSessionAsk_RequiresAgentFlag(t *testing.T) {
// Build the real cobra command with a nil factory — flag parsing happens
// before RunE so the factory is never dereferenced for this test.
f := &cmdutil.Factory{}
cmd := NewCmdAsk(f)
// Redirect output to discard cobra error messages.
var buf bytes.Buffer
cmd.SetOut(&buf)
cmd.SetErr(&buf)
// Execute without --agent: cobra should refuse with exit-code 2.
cmd.SetArgs([]string{"some question"})
err := cmd.Execute()
if err == nil {
t.Fatal("expected error when --agent is missing, got nil")
}
// Cobra wraps required-flag errors; the message should mention the flag.
if !strings.Contains(err.Error(), "agent") {
t.Errorf("error should mention 'agent' flag, got: %v", err)
}
}
// TestSessionAsk_NDJSON_IncludesReferencesViaSDKEvent verifies that references
// emitted by the SDK appear as passthrough NDJSON lines (not lost).
func TestSessionAsk_NDJSON_IncludesReferencesViaSDKEvent(t *testing.T) {
out, _ := iostreams.SetForTest(t)
svc := &scriptedAskSvc{
events: []*sdk.AgentStreamResponse{
answerEvent("Hello world."),
referencesEvent([]*sdk.SearchResult{{KnowledgeID: "k1", KnowledgeTitle: "Doc 1"}}),
doneEvent(),
},
}
opts := &AskOptions{AgentID: "ag_x", Query: "ping"}
if err := runAsk(context.Background(), opts, jsonOpts(), svc); err != nil {
t.Fatalf("runAsk: %v", err)
}
lines := strings.Split(strings.TrimRight(out.String(), "\n"), "\n")
// 1 init + 3 SDK events = 4 lines.
if len(lines) != 4 {
t.Fatalf("got %d NDJSON lines, want 4:\n%s", len(lines), out.String())
}
// init line.
var init map[string]any
if err := json.Unmarshal([]byte(lines[0]), &init); err != nil {
t.Fatalf("line 0 not JSON: %v", err)
}
if init["type"] != "init" {
t.Errorf("line 0 type: got %v, want init", init["type"])
}
// references line is the third SDK event (lines[3] = index 3).
var refsLine map[string]any
if err := json.Unmarshal([]byte(lines[2]), &refsLine); err != nil {
t.Fatalf("references line not JSON: %v", err)
}
if refsLine["response_type"] != string(sdk.AgentResponseTypeReferences) {
t.Errorf("expected references event at line 3, got response_type=%v", refsLine["response_type"])
}
}
+3 -4
View File
@@ -1,9 +1,9 @@
// Package sessioncmd holds `weknora session` command tree (list / view /
// delete) for chat history.
// delete / ask) for chat history and agent invocation.
//
// Package name `sessioncmd` (not `session`) so callers can `import sdk
// "github.com/Tencent/WeKnora/client"` and use `sdk.Session` without
// shadowing - same hygiene as `contextcmd`.
// shadowing - same hygiene as `profilecmd`.
package sessioncmd
import (
@@ -17,11 +17,10 @@ func NewCmd(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "session",
Short: "Manage chat sessions",
Args: cobra.NoArgs,
Run: func(c *cobra.Command, _ []string) { _ = c.Help() },
}
cmd.AddCommand(NewCmdList(f))
cmd.AddCommand(NewCmdView(f))
cmd.AddCommand(NewCmdDelete(f))
cmd.AddCommand(NewCmdAsk(f))
return cmd
}