chat api (#991)

- update chat docs
- add messages chat endpoint
- remove deprecated context and template generate parameters from docs
- context and template are still supported for the time being and will continue to work as expected
- add partial response to chat history

cmd/cmd.go

@@ -159,7 +159,54 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	return RunGenerate(cmd, args)
+	interactive := true
+
+	opts := runOptions{
+		Model:    name,
+		WordWrap: os.Getenv("TERM") == "xterm-256color",
+		Options:  map[string]interface{}{},
+	}
+
+	format, err := cmd.Flags().GetString("format")
+	if err != nil {
+		return err
+	}
+	opts.Format = format
+
+	prompts := args[1:]
+
+	// prepend stdin to the prompt if provided
+	if !term.IsTerminal(int(os.Stdin.Fd())) {
+		in, err := io.ReadAll(os.Stdin)
+		if err != nil {
+			return err
+		}
+
+		prompts = append([]string{string(in)}, prompts...)
+		opts.WordWrap = false
+		interactive = false
+	}
+	msg := api.Message{
+		Role:    "user",
+		Content: strings.Join(prompts, " "),
+	}
+	opts.Messages = append(opts.Messages, msg)
+	if len(prompts) > 0 {
+		interactive = false
+	}
+
+	nowrap, err := cmd.Flags().GetBool("nowordwrap")
+	if err != nil {
+		return err
+	}
+	opts.WordWrap = !nowrap
+
+	if !interactive {
+		_, err := chat(cmd, opts)
+		return err
+	}
+
+	return chatInteractive(cmd, opts)
 }
 
 func PushHandler(cmd *cobra.Command, args []string) error {
@@ -411,83 +458,26 @@ func PullHandler(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
-func RunGenerate(cmd *cobra.Command, args []string) error {
-	interactive := true
-
-	opts := generateOptions{
-		Model:    args[0],
-		WordWrap: os.Getenv("TERM") == "xterm-256color",
-		Options:  map[string]interface{}{},
-	}
-
-	format, err := cmd.Flags().GetString("format")
-	if err != nil {
-		return err
-	}
-	opts.Format = format
-
-	prompts := args[1:]
-
-	// prepend stdin to the prompt if provided
-	if !term.IsTerminal(int(os.Stdin.Fd())) {
-		in, err := io.ReadAll(os.Stdin)
-		if err != nil {
-			return err
-		}
-
-		prompts = append([]string{string(in)}, prompts...)
-		opts.WordWrap = false
-		interactive = false
-	}
-	opts.Prompt = strings.Join(prompts, " ")
-	if len(prompts) > 0 {
-		interactive = false
-	}
-
-	nowrap, err := cmd.Flags().GetBool("nowordwrap")
-	if err != nil {
-		return err
-	}
-	opts.WordWrap = !nowrap
-
-	if !interactive {
-		return generate(cmd, opts)
-	}
-
-	return generateInteractive(cmd, opts)
-}
-
-type generateContextKey string
-
-type generateOptions struct {
+type runOptions struct {
 	Model    string
-	Prompt   string
+	Messages []api.Message
 	WordWrap bool
 	Format   string
-	System   string
 	Template string
 	Options  map[string]interface{}
 }
 
-func generate(cmd *cobra.Command, opts generateOptions) error {
+func chat(cmd *cobra.Command, opts runOptions) (*api.Message, error) {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	p := progress.NewProgress(os.Stderr)
 	defer p.StopAndClear()
-
 	spinner := progress.NewSpinner("")
 	p.Add("", spinner)
 
-	var latest api.GenerateResponse
-
-	generateContext, ok := cmd.Context().Value(generateContextKey("context")).([]int)
-	if !ok {
-		generateContext = []int{}
-	}
-
 	termWidth, _, err := term.GetSize(int(os.Stdout.Fd()))
 	if err != nil {
 		opts.WordWrap = false
@@ -506,24 +496,24 @@ func generate(cmd *cobra.Command, opts generateOptions) error {
 
 	var currentLineLength int
 	var wordBuffer string
+	var latest api.ChatResponse
+	var fullResponse strings.Builder
+	var role string
 
-	request := api.GenerateRequest{
-		Model:    opts.Model,
-		Prompt:   opts.Prompt,
-		Context:  generateContext,
-		Format:   opts.Format,
-		System:   opts.System,
-		Template: opts.Template,
-		Options:  opts.Options,
-	}
-	fn := func(response api.GenerateResponse) error {
+	fn := func(response api.ChatResponse) error {
 		p.StopAndClear()
-
 		latest = response
+		if response.Message == nil {
+			// warm-up response or done
+			return nil
+		}
+		role = response.Message.Role
+		content := response.Message.Content
+		fullResponse.WriteString(content)
 
 		termWidth, _, _ = term.GetSize(int(os.Stdout.Fd()))
 		if opts.WordWrap && termWidth >= 10 {
-			for _, ch := range response.Response {
+			for _, ch := range content {
 				if currentLineLength+1 > termWidth-5 {
 					if len(wordBuffer) > termWidth-10 {
 						fmt.Printf("%s%c", wordBuffer, ch)
@@ -551,7 +541,7 @@ func generate(cmd *cobra.Command, opts generateOptions) error {
 				}
 			}
 		} else {
-			fmt.Printf("%s%s", wordBuffer, response.Response)
+			fmt.Printf("%s%s", wordBuffer, content)
 			if len(wordBuffer) > 0 {
 				wordBuffer = ""
 			}
@@ -560,35 +550,35 @@ func generate(cmd *cobra.Command, opts generateOptions) error {
 		return nil
 	}
 
-	if err := client.Generate(cancelCtx, &request, fn); err != nil {
-		if errors.Is(err, context.Canceled) {
-			return nil
-		}
-		return err
+	req := &api.ChatRequest{
+		Model:    opts.Model,
+		Messages: opts.Messages,
+		Format:   opts.Format,
+		Template: opts.Template,
+		Options:  opts.Options,
 	}
-	if opts.Prompt != "" {
-		fmt.Println()
-		fmt.Println()
+	if err := client.Chat(cancelCtx, req, fn); err != nil {
+		if errors.Is(err, context.Canceled) {
+			return nil, nil
+		}
+		return nil, err
 	}
 
-	if !latest.Done {
-		return nil
+	if len(opts.Messages) > 0 {
+		fmt.Println()
+		fmt.Println()
 	}
 
 	verbose, err := cmd.Flags().GetBool("verbose")
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	if verbose {
 		latest.Summary()
 	}
 
-	ctx := cmd.Context()
-	ctx = context.WithValue(ctx, generateContextKey("context"), latest.Context)
-	cmd.SetContext(ctx)
-
-	return nil
+	return &api.Message{Role: role, Content: fullResponse.String()}, nil
 }
 
 type MultilineState int
@@ -600,13 +590,10 @@ const (
 	MultilineTemplate
 )
 
-func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
+func chatInteractive(cmd *cobra.Command, opts runOptions) error {
 	// load the model
-	loadOpts := generateOptions{
-		Model:  opts.Model,
-		Prompt: "",
-	}
-	if err := generate(cmd, loadOpts); err != nil {
+	loadOpts := runOptions{Model: opts.Model}
+	if _, err := chat(cmd, loadOpts); err != nil {
 		return err
 	}
 
@@ -677,7 +664,9 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 	defer fmt.Printf(readline.EndBracketedPaste)
 
 	var multiline MultilineState
-	var prompt string
+	var content string
+	var systemContent string
+	opts.Messages = make([]api.Message, 0)
 
 	for {
 		line, err := scanner.Readline()
@@ -691,7 +680,7 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 			}
 
 			scanner.Prompt.UseAlt = false
-			prompt = ""
+			content = ""
 
 			continue
 		case err != nil:
@@ -699,37 +688,37 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 		}
 
 		switch {
-		case strings.HasPrefix(prompt, `"""`):
+		case strings.HasPrefix(content, `"""`):
 			// if the prompt so far starts with """ then we're in multiline mode
 			// and we need to keep reading until we find a line that ends with """
 			cut, found := strings.CutSuffix(line, `"""`)
-			prompt += cut + "\n"
+			content += cut + "\n"
 
 			if !found {
 				continue
 			}
 
-			prompt = strings.TrimPrefix(prompt, `"""`)
+			content = strings.TrimPrefix(content, `"""`)
 			scanner.Prompt.UseAlt = false
 
 			switch multiline {
 			case MultilineSystem:
-				opts.System = prompt
-				prompt = ""
+				systemContent = content
+				content = ""
 				fmt.Println("Set system template.\n")
 			case MultilineTemplate:
-				opts.Template = prompt
-				prompt = ""
+				opts.Template = content
+				content = ""
 				fmt.Println("Set model template.\n")
 			}
 			multiline = MultilineNone
-		case strings.HasPrefix(line, `"""`) && len(prompt) == 0:
+		case strings.HasPrefix(line, `"""`) && len(content) == 0:
 			scanner.Prompt.UseAlt = true
 			multiline = MultilinePrompt
-			prompt += line + "\n"
+			content += line + "\n"
 			continue
 		case scanner.Pasting:
-			prompt += line + "\n"
+			content += line + "\n"
 			continue
 		case strings.HasPrefix(line, "/list"):
 			args := strings.Fields(line)
@@ -791,17 +780,17 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 					line = strings.TrimPrefix(line, `"""`)
 					if strings.HasPrefix(args[2], `"""`) {
 						cut, found := strings.CutSuffix(line, `"""`)
-						prompt += cut + "\n"
+						content += cut + "\n"
 						if found {
-							opts.System = prompt
+							systemContent = content
 							if args[1] == "system" {
 								fmt.Println("Set system template.\n")
 							} else {
 								fmt.Println("Set prompt template.\n")
 							}
-							prompt = ""
+							content = ""
 						} else {
-							prompt = `"""` + prompt
+							content = `"""` + content
 							if args[1] == "system" {
 								multiline = MultilineSystem
 							} else {
@@ -810,7 +799,7 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 							scanner.Prompt.UseAlt = true
 						}
 					} else {
-						opts.System = line
+						systemContent = line
 						fmt.Println("Set system template.\n")
 					}
 				default:
@@ -858,8 +847,8 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 					}
 				case "system":
 					switch {
-					case opts.System != "":
-						fmt.Println(opts.System + "\n")
+					case systemContent != "":
+						fmt.Println(systemContent + "\n")
 					case resp.System != "":
 						fmt.Println(resp.System + "\n")
 					default:
@@ -899,16 +888,23 @@ func generateInteractive(cmd *cobra.Command, opts generateOptions) error {
 			fmt.Printf("Unknown command '%s'. Type /? for help\n", args[0])
 			continue
 		default:
-			prompt += line
+			content += line
 		}
 
-		if len(prompt) > 0 && multiline == MultilineNone {
-			opts.Prompt = prompt
-			if err := generate(cmd, opts); err != nil {
+		if len(content) > 0 && multiline == MultilineNone {
+			if systemContent != "" {
+				opts.Messages = append(opts.Messages, api.Message{Role: "system", Content: systemContent})
+			}
+			opts.Messages = append(opts.Messages, api.Message{Role: "user", Content: content})
+			assistant, err := chat(cmd, opts)
+			if err != nil {
 				return err
 			}
+			if assistant != nil {
+				opts.Messages = append(opts.Messages, *assistant)
+			}
 
-			prompt = ""
+			content = ""
 		}
 	}
 }