add back in the windows terminal file

README.md

@@ -225,7 +225,6 @@ See the [API documentation](./docs/api.md) for all endpoints.
 - [Web UI](https://github.com/ollama-webui/ollama-webui)
 - [Ollamac](https://github.com/kevinhermawan/Ollamac)
 - [big-AGI](https://github.com/enricoros/big-agi/blob/main/docs/config-ollama.md)
-- [Cheshire Cat assistant framework](https://github.com/cheshire-cat-ai/core)
 
 ### Terminal
 
@@ -248,10 +247,6 @@ See the [API documentation](./docs/api.md) for all endpoints.
 - [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
 - [Ollama for Dart](https://github.com/breitburg/dart-ollama)
 
-### Mobile
-
-- [Maid](https://github.com/danemadsen/Maid) (Mobile Artificial Intelligence Distribution)
-
 ### Extensions & Plugins
 
 - [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)

api/client.go

@@ -5,7 +5,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net"
@@ -96,19 +95,11 @@ func (c *Client) do(ctx context.Context, method, path string, reqData, respData
 	var reqBody io.Reader
 	var data []byte
 	var err error
-
-	switch reqData := reqData.(type) {
-	case io.Reader:
-		// reqData is already an io.Reader
-		reqBody = reqData
-	case nil:
-		// noop
-	default:
+	if reqData != nil {
 		data, err = json.Marshal(reqData)
 		if err != nil {
 			return err
 		}
-
 		reqBody = bytes.NewReader(data)
 	}
 
@@ -296,18 +287,3 @@ func (c *Client) Heartbeat(ctx context.Context) error {
 	}
 	return nil
 }
-
-func (c *Client) CreateBlob(ctx context.Context, digest string, r io.Reader) error {
-	if err := c.do(ctx, http.MethodHead, fmt.Sprintf("/api/blobs/%s", digest), nil, nil); err != nil {
-		var statusError StatusError
-		if !errors.As(err, &statusError) || statusError.StatusCode != http.StatusNotFound {
-			return err
-		}
-
-		if err := c.do(ctx, http.MethodPost, fmt.Sprintf("/api/blobs/%s", digest), r, nil); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

api/types.go

@@ -99,10 +99,9 @@ type EmbeddingResponse struct {
 }
 
 type CreateRequest struct {
-	Name      string `json:"name"`
-	Path      string `json:"path"`
-	Modelfile string `json:"modelfile"`
-	Stream    *bool  `json:"stream,omitempty"`
+	Name   string `json:"name"`
+	Path   string `json:"path"`
+	Stream *bool  `json:"stream,omitempty"`
 }
 
 type DeleteRequest struct {

cmd/cmd.go

@@ -1,11 +1,9 @@
 package cmd
 
 import (
-	"bytes"
 	"context"
 	"crypto/ed25519"
 	"crypto/rand"
-	"crypto/sha256"
 	"encoding/pem"
 	"errors"
 	"fmt"
@@ -22,16 +20,16 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/dustin/go-humanize"
 	"github.com/olekukonko/tablewriter"
 	"github.com/spf13/cobra"
 	"golang.org/x/crypto/ssh"
 	"golang.org/x/term"
 
 	"github.com/jmorganca/ollama/api"
+	"github.com/jmorganca/ollama/editor"
 	"github.com/jmorganca/ollama/format"
-	"github.com/jmorganca/ollama/parser"
 	"github.com/jmorganca/ollama/progressbar"
-	"github.com/jmorganca/ollama/readline"
 	"github.com/jmorganca/ollama/server"
 	"github.com/jmorganca/ollama/version"
 )
@@ -48,64 +46,17 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	modelfile, err := os.ReadFile(filename)
-	if err != nil {
-		return err
-	}
-
-	spinner := NewSpinner("transferring context")
-	go spinner.Spin(100 * time.Millisecond)
-
-	commands, err := parser.Parse(bytes.NewReader(modelfile))
-	if err != nil {
-		return err
-	}
-
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return err
-	}
-
-	for _, c := range commands {
-		switch c.Name {
-		case "model", "adapter":
-			path := c.Args
-			if path == "~" {
-				path = home
-			} else if strings.HasPrefix(path, "~/") {
-				path = filepath.Join(home, path[2:])
-			}
-
-			bin, err := os.Open(path)
-			if errors.Is(err, os.ErrNotExist) && c.Name == "model" {
-				continue
-			} else if err != nil {
-				return err
-			}
-			defer bin.Close()
-
-			hash := sha256.New()
-			if _, err := io.Copy(hash, bin); err != nil {
-				return err
-			}
-			bin.Seek(0, io.SeekStart)
-
-			digest := fmt.Sprintf("sha256:%x", hash.Sum(nil))
-			if err = client.CreateBlob(cmd.Context(), digest, bin); err != nil {
-				return err
-			}
-
-			modelfile = bytes.ReplaceAll(modelfile, []byte(c.Args), []byte("@"+digest))
-		}
-	}
+	var spinner *Spinner
 
 	var currentDigest string
 	var bar *progressbar.ProgressBar
 
-	request := api.CreateRequest{Name: args[0], Path: filename, Modelfile: string(modelfile)}
+	request := api.CreateRequest{Name: args[0], Path: filename}
 	fn := func(resp api.ProgressResponse) error {
 		if resp.Digest != currentDigest && resp.Digest != "" {
-			spinner.Stop()
+			if spinner != nil {
+				spinner.Stop()
+			}
 			currentDigest = resp.Digest
 			// pulling
 			bar = progressbar.DefaultBytes(
@@ -117,7 +68,9 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 			bar.Set64(resp.Completed)
 		} else {
 			currentDigest = ""
-			spinner.Stop()
+			if spinner != nil {
+				spinner.Stop()
+			}
 			spinner = NewSpinner(resp.Status)
 			go spinner.Spin(100 * time.Millisecond)
 		}
@@ -129,9 +82,11 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	spinner.Stop()
-	if spinner.description != "success" {
-		return errors.New("unexpected end to create model")
+	if spinner != nil {
+		spinner.Stop()
+		if spinner.description != "success" {
+			return errors.New("unexpected end to create model")
+		}
 	}
 
 	return nil
@@ -218,7 +173,7 @@ func ListHandler(cmd *cobra.Command, args []string) error {
 
 	for _, m := range models.Models {
 		if len(args) == 0 || strings.HasPrefix(m.Name, args[0]) {
-			data = append(data, []string{m.Name, m.Digest[:12], format.HumanBytes(m.Size), format.HumanTime(m.ModifiedAt, "Never")})
+			data = append(data, []string{m.Name, m.Digest[:12], humanize.Bytes(uint64(m.Size)), format.HumanTime(m.ModifiedAt, "Never")})
 		}
 	}
 
@@ -584,30 +539,24 @@ func generateInteractive(cmd *cobra.Command, model string, wordWrap bool, format
 		fmt.Fprintln(os.Stderr, "")
 	}
 
-	prompt := readline.Prompt{
-		Prompt:         ">>> ",
-		AltPrompt:      "... ",
-		Placeholder:    "Send a message (/? for help)",
-		AltPlaceholder: `Use """ to end multi-line input`,
+	prompt := editor.Prompt{
+		Prompt:      ">>> ",
+		AltPrompt:   "... ",
+		Placeholder: "Send a message (/? for help)",
 	}
 
-	scanner, err := readline.New(prompt)
+	ed, err := editor.New(prompt)
 	if err != nil {
 		return err
 	}
 
-	fmt.Print(readline.StartBracketedPaste)
-	defer fmt.Printf(readline.EndBracketedPaste)
-
-	var multiLineBuffer string
-
 	for {
-		line, err := scanner.Readline()
+		line, err := ed.HandleInput()
 		switch {
 		case errors.Is(err, io.EOF):
 			fmt.Println()
 			return nil
-		case errors.Is(err, readline.ErrInterrupt):
+		case errors.Is(err, editor.ErrInterrupt):
 			if line == "" {
 				fmt.Println("\nUse Ctrl-D or /bye to exit.")
 			}
@@ -620,20 +569,6 @@ func generateInteractive(cmd *cobra.Command, model string, wordWrap bool, format
 		line = strings.TrimSpace(line)
 
 		switch {
-		case scanner.Prompt.UseAlt:
-			if strings.HasSuffix(line, `"""`) {
-				scanner.Prompt.UseAlt = false
-				multiLineBuffer += strings.TrimSuffix(line, `"""`)
-				line = multiLineBuffer
-				multiLineBuffer = ""
-			} else {
-				multiLineBuffer += line + " "
-				continue
-			}
-		case strings.HasPrefix(line, `"""`):
-			scanner.Prompt.UseAlt = true
-			multiLineBuffer = strings.TrimPrefix(line, `"""`) + " "
-			continue
 		case strings.HasPrefix(line, "/list"):
 			args := strings.Fields(line)
 			if err := ListHandler(cmd, args[1:]); err != nil {
@@ -644,9 +579,9 @@ func generateInteractive(cmd *cobra.Command, model string, wordWrap bool, format
 			if len(args) > 1 {
 				switch args[1] {
 				case "history":
-					scanner.HistoryEnable()
+					//scanner.HistoryEnable()
 				case "nohistory":
-					scanner.HistoryDisable()
+					//scanner.HistoryDisable()
 				case "wordwrap":
 					wordWrap = true
 					fmt.Println("Set 'wordwrap' mode.")

docs/api.md

@@ -292,13 +292,12 @@ curl -X POST http://localhost:11434/api/generate -d '{
 POST /api/create
 ```
 
-Create a model from a [`Modelfile`](./modelfile.md). It is recommended to set `modelfile` to the content of the Modelfile rather than just set `path`. This is a requirement for remote create. Remote model creation should also create any file blobs, fields such as `FROM` and `ADAPTER`, explicitly with the server using [Create a Blob](#create-a-blob) and the value to the path indicated in the response.
+Create a model from a [`Modelfile`](./modelfile.md)
 
 ### Parameters
 
 - `name`: name of the model to create
-- `path`: path to the Modelfile (deprecated: please use modelfile instead)
-- `modelfile`: contents of the Modelfile
+- `path`: path to the Modelfile
 - `stream`: (optional) if `false` the response will be returned as a single response object, rather than a stream of objects
 
 ### Examples
@@ -308,8 +307,7 @@ Create a model from a [`Modelfile`](./modelfile.md). It is recommended to set `m
 ```shell
 curl -X POST http://localhost:11434/api/create -d '{
   "name": "mario",
-  "path": "~/Modelfile",
-  "modelfile": "FROM llama2"
+  "path": "~/Modelfile"
 }'
 ```
 
@@ -323,54 +321,6 @@ A stream of JSON objects. When finished, `status` is `success`.
 }
 ```
 
-### Check if a Blob Exists
-
-```shell
-HEAD /api/blobs/:digest
-```
-
-Check if a blob is known to the server.
-
-#### Query Parameters
-
-- `digest`: the SHA256 digest of the blob
-
-#### Examples
-
-##### Request
-
-```shell
-curl -I http://localhost:11434/api/blobs/sha256:29fdb92e57cf0827ded04ae6461b5931d01fa595843f55d36f5b275a52087dd2
-```
-
-##### Response
-
-Return 200 OK if the blob exists, 404 Not Found if it does not.
-
-### Create a Blob
-
-```shell
-POST /api/blobs/:digest
-```
-
-Create a blob from a file. Returns the server file path.
-
-#### Query Parameters
-
-- `digest`: the expected SHA256 digest of the file
-
-#### Examples
-
-##### Request
-
-```shell
-curl -T model.bin -X POST http://localhost:11434/api/blobs/sha256:29fdb92e57cf0827ded04ae6461b5931d01fa595843f55d36f5b275a52087dd2
-```
-
-##### Response
-
-Return 201 Created if the blob was successfully created.
-
 ## List Local Models
 
 ```shell

docs/faq.md

@@ -32,11 +32,11 @@ Create a `systemd` drop-in directory and set `Environment=OLLAMA_HOST`
 
 ```bash
 mkdir -p /etc/systemd/system/ollama.service.d
-echo '[Service]' >>/etc/systemd/system/ollama.service.d/environment.conf
+echo "[Service]" >>/etc/systemd/system/ollama.service.d/environment.conf
 ```
 
 ```bash
-echo 'Environment="OLLAMA_HOST=0.0.0.0:11434"' >>/etc/systemd/system/ollama.service.d/environment.conf
+echo "Environment=OLLAMA_HOST=0.0.0.0:11434" >>/etc/systemd/system/ollama.service.d/environment.conf
 ```
 
 Reload `systemd` and restart Ollama:
@@ -59,7 +59,7 @@ OLLAMA_ORIGINS=http://192.168.1.1:*,https://example.com ollama serve
 On Linux:
 
 ```bash
-echo 'Environment="OLLAMA_ORIGINS=http://129.168.1.1:*,https://example.com"' >>/etc/systemd/system/ollama.service.d/environment.conf
+echo "Environment=OLLAMA_ORIGINS=http://129.168.1.1:*,https://example.com" >>/etc/systemd/system/ollama.service.d/environment.conf
 ```
 
 Reload `systemd` and restart Ollama:
@@ -74,6 +74,8 @@ systemctl restart ollama
 - macOS: Raw model data is stored under `~/.ollama/models`.
 - Linux: Raw model data is stored under `/usr/share/ollama/.ollama/models`
 
+
+
 Below the models directory you will find a structure similar to the following:
 
 ```shell
@@ -94,57 +96,3 @@ The manifest lists all the layers used in this model. You will see a `media type
 ### How can I change where Ollama stores models?
 
 To modify where models are stored, you can use the `OLLAMA_MODELS` environment variable. Note that on Linux this means defining `OLLAMA_MODELS` in a drop-in `/etc/systemd/system/ollama.service.d` service file, reloading systemd, and restarting the ollama service.
-
-## Does Ollama send my prompts and answers back to Ollama.ai to use in any way?
-
-No. Anything you do with Ollama, such as generate a response from the model, stays with you. We don't collect any data about how you use the model. You are always in control of your own data.
-
-## How can I use Ollama in Visual Studio Code?
-
-There is already a large collection of plugins available for VSCode as well as other editors that leverage Ollama. You can see the list of [extensions & plugins](https://github.com/jmorganca/ollama#extensions--plugins) at the bottom of the main repository readme.
-
-## How do I use Ollama behind a proxy?
-
-Ollama is compatible with proxy servers if `HTTP_PROXY` or `HTTPS_PROXY` are configured. When using either variables, ensure it is set where `ollama serve` can access the values.
-
-When using `HTTPS_PROXY`, ensure the proxy certificate is installed as a system certificate.
-
-On macOS:
-
-```bash
-HTTPS_PROXY=http://proxy.example.com ollama serve
-```
-
-On Linux:
-
-```bash
-echo 'Environment="HTTPS_PROXY=https://proxy.example.com"' >>/etc/systemd/system/ollama.service.d/environment.conf
-```
-
-Reload `systemd` and restart Ollama:
-
-```bash
-systemctl daemon-reload
-systemctl restart ollama
-```
-
-### How do I use Ollama behind a proxy in Docker?
-
-The Ollama Docker container image can be configured to use a proxy by passing `-e HTTPS_PROXY=https://proxy.example.com` when starting the container.
-
-Alternatively, Docker daemon can be configured to use a proxy. Instructions are available for Docker Desktop on [macOS](https://docs.docker.com/desktop/settings/mac/#proxies), [Windows](https://docs.docker.com/desktop/settings/windows/#proxies), and [Linux](https://docs.docker.com/desktop/settings/linux/#proxies), and Docker [daemon with systemd](https://docs.docker.com/config/daemon/systemd/#httphttps-proxy).
-
-Ensure the certificate is installed as a system certificate when using HTTPS. This may require a new Docker image when using a self-signed certificate.
-
-```dockerfile
-FROM ollama/ollama
-COPY my-ca.pem /usr/local/share/ca-certificates/my-ca.crt
-RUN update-ca-certificate
-```
-
-Build and run this image:
-
-```shell
-docker build -t ollama-with-ca .
-docker run -d -e HTTPS_PROXY=https://my.proxy.example.com -p 11434:11434 ollama-with-ca
-```

docs/tutorials.md

@@ -4,6 +4,5 @@ Here is a list of ways you can use Ollama with other tools to build interesting
 
 - [Using LangChain with Ollama in JavaScript](./tutorials/langchainjs.md)
 - [Using LangChain with Ollama in Python](./tutorials/langchainpy.md)
-- [Running Ollama on NVIDIA Jetson Devices](./tutorials/nvidia-jetson.md)
 
-Also be sure to check out the [examples](../examples) directory for more ways to use Ollama.
+Also be sure to check out the [examples](../examples) directory for more ways to use Ollama.

docs/tutorials/nvidia-jetson.md

@@ -1,38 +0,0 @@
-# Running Ollama on NVIDIA Jetson Devices
-
-With some minor configuration, Ollama runs well on [NVIDIA Jetson Devices](https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/). The following has been tested on [JetPack 5.1.2](https://developer.nvidia.com/embedded/jetpack).
-
-NVIDIA Jetson devices are Linux-based embedded AI computers that are purpose-built for AI applications.
-
-Jetsons have an integrated GPU that is wired directly to the memory controller of the machine. For this reason, the `nvidia-smi` command is unrecognized, and Ollama proceeds to operate in "CPU only"
-mode. This can be verified by using a monitoring tool like jtop.
-
-In order to address this, we simply pass the path to the Jetson's pre-installed CUDA libraries into `ollama serve` (while in a tmux session). We then hardcode the num_gpu parameters into a cloned
-version of our target model.
-
-Prerequisites:
-
-- curl
-- tmux
-
-Here are the steps:
-
-- Install Ollama via standard Linux command (ignore the 404 error): `curl https://ollama.ai/install.sh | sh`
-- Stop the Ollama service: `sudo systemctl stop ollama`
-- Start Ollama serve in a tmux session called ollama_jetson and reference the CUDA libraries path: `tmux has-session -t ollama_jetson 2>/dev/null || tmux new-session -d -s ollama_jetson 
-'LD_LIBRARY_PATH=/usr/local/cuda/lib64 ollama serve'`
-- Pull the model you want to use (e.g. mistral): `ollama pull mistral`
-- Create a new Modelfile specifically for enabling GPU support on the Jetson: `touch ModelfileMistralJetson`
-- In the ModelfileMistralJetson file, specify the FROM model and the num_gpu PARAMETER as shown below:
-
-```
-FROM mistral
-PARAMETER num_gpu 999
-```
-
-- Create a new model from your Modelfile: `ollama create mistral-jetson -f ./ModelfileMistralJetson`
-- Run the new model: `ollama run mistral-jetson`
-
-If you run a monitoring tool like jtop you should now see that Ollama is using the Jetson's integrated GPU.
-
-And that's it!

editor/buffer.go

@@ -0,0 +1,488 @@
+package editor
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/emirpasic/gods/lists/arraylist"
+	"golang.org/x/term"
+)
+
+type Buffer struct {
+	PosX         int
+	PosY         int
+	Buf          []*arraylist.List
+	Prompt       *Prompt
+	WordWrap     int
+	ScreenWidth  int
+	ScreenHeight int
+}
+
+func NewBuffer(prompt *Prompt) (*Buffer, error) {
+	width, height, err := term.GetSize(0)
+	if err != nil {
+		fmt.Println("Error getting size:", err)
+		return nil, err
+	}
+
+	b := &Buffer{
+		PosX:         0,
+		PosY:         0,
+		Buf:          []*arraylist.List{arraylist.New()},
+		Prompt:       prompt,
+		ScreenWidth:  width,
+		ScreenHeight: height,
+	}
+
+	return b, nil
+}
+
+func (b *Buffer) LineWidth() int {
+	return b.ScreenWidth - len(b.Prompt.Prompt)
+}
+
+func (b *Buffer) findWordAtPos(line string, pos int) string {
+	return ""
+}
+
+func (b *Buffer) addLine(row int) {
+	if row+1 == len(b.Buf) {
+		b.Buf = append(b.Buf, arraylist.New())
+	} else {
+		b.Buf = append(b.Buf, nil)
+		copy(b.Buf[row+2:], b.Buf[row+1:])
+		b.Buf[row+1] = arraylist.New()
+	}
+}
+
+func (b *Buffer) Add(r rune) {
+	switch r {
+	case CharCtrlJ, CharEnter:
+		b.addLine(b.PosY)
+
+		// handle Ctrl-J in the middle of a line
+		var remainingText string
+		if b.PosX < b.Buf[b.PosY].Size() {
+			fmt.Print(ClearToEOL)
+			remainingText = b.StringLine(b.PosX, b.PosY)
+			for cnt := 0; cnt < len(remainingText); cnt++ {
+				b.Buf[b.PosY].Remove(b.Buf[b.PosY].Size() - 1)
+				b.Buf[b.PosY+1].Add(rune(remainingText[cnt]))
+			}
+		}
+		b.PosY++
+		b.PosX = 0
+		fmt.Printf("\n... " + ClearToEOL)
+		b.drawRemaining()
+	default:
+		if b.PosX == b.Buf[b.PosY].Size() {
+			fmt.Printf("%c", r)
+			b.PosX++
+			b.Buf[b.PosY].Add(r)
+			wrap, prefix, offset := b.splitLineInsert(b.PosY, b.PosX)
+			if wrap {
+				fmt.Print(CursorHide + cursorLeftN(len(prefix)+1) + ClearToEOL)
+				fmt.Printf("\n%s... %s%c", ClearToEOL, prefix, r)
+				b.PosY++
+				b.PosX = offset
+				b.ResetCursor()
+				b.drawRemaining()
+				fmt.Print(CursorShow)
+			}
+		} else {
+			fmt.Printf("%c", r)
+			b.Buf[b.PosY].Insert(b.PosX, r)
+			b.PosX++
+			_, prefix, offset := b.splitLineInsert(b.PosY, b.PosX)
+			fmt.Print(CursorHide)
+			if b.PosX > b.Buf[b.PosY].Size() {
+				if offset > 0 {
+					fmt.Print(cursorLeftN(offset))
+				}
+				fmt.Print(ClearToEOL + CursorDown + CursorBOL + ClearToEOL)
+				fmt.Printf("... %s", prefix[:offset])
+				b.PosY++
+				b.PosX = offset
+				b.ResetCursor()
+			}
+			b.drawRemaining()
+			fmt.Print(CursorShow)
+		}
+	}
+}
+
+func (b *Buffer) ResetCursor() {
+	fmt.Print(CursorHide + CursorBOL)
+	fmt.Print(cursorRightN(b.PosX + len(b.Prompt.Prompt)))
+	fmt.Print(CursorShow)
+}
+
+func (b *Buffer) splitLineInsert(posY, posX int) (bool, string, int) {
+	line := b.StringLine(0, posY)
+	screenEdge := b.LineWidth() - 5
+
+	// if the current line doesn't need to be reflowed, none of the other
+	// lines will either
+	if len(line) <= screenEdge {
+		return false, "", 0
+	}
+
+	// we know we're going to have to insert onto the next line, so
+	// add another line if there isn't one already
+	if posY == len(b.Buf)-1 {
+		b.Buf = append(b.Buf, arraylist.New())
+	}
+
+	// make a truncated version of the current line
+	currLine := line[:screenEdge]
+
+	// figure out where the last space in the line is
+	idx := strings.LastIndex(currLine, " ")
+
+	// deal with strings that don't have spaces in them
+	if idx == -1 {
+		idx = len(currLine) - 1
+	}
+
+	// if the next line already has text on it, we need
+	// to add a space to insert our new word
+	if b.Buf[posY+1].Size() > 0 {
+		b.Buf[posY+1].Insert(0, ' ')
+	}
+
+	// calculate the number of characters we need to remove
+	// from the current line to add to the next one
+	totalChars := len(line) - idx - 1
+
+	for cnt := 0; cnt < totalChars; cnt++ {
+		b.Buf[posY].Remove(b.Buf[posY].Size() - 1)
+		b.Buf[posY+1].Insert(0, rune(line[len(line)-1-cnt]))
+	}
+	// remove the trailing space
+	b.Buf[posY].Remove(b.Buf[posY].Size() - 1)
+
+	// wrap any further lines
+	if b.Buf[posY+1].Size() > b.LineWidth()-5 {
+		b.splitLineInsert(posY+1, 0)
+	}
+
+	return true, currLine[idx+1:], posX - idx - 1
+}
+
+func (b *Buffer) drawRemaining() {
+	remainingText := b.StringFromRow(b.PosY)
+	remainingText = remainingText[b.PosX:]
+
+	fmt.Print(CursorHide + ClearToEOL)
+
+	var rowCount int
+	for _, c := range remainingText {
+		fmt.Print(string(c))
+		if c == '\n' {
+			fmt.Print("... " + ClearToEOL)
+			rowCount++
+		}
+	}
+	if rowCount > 0 {
+		fmt.Print(cursorUpN(rowCount))
+	}
+	b.ResetCursor()
+}
+
+func (b *Buffer) findWordBeginning(posX int) int {
+	for {
+		if posX < 0 {
+			return -1
+		}
+		r, ok := b.Buf[b.PosY].Get(posX)
+		if !ok {
+			return -1
+		} else if r.(rune) == ' ' {
+			return posX
+		}
+		posX--
+	}
+}
+
+func (b *Buffer) Delete() {
+	if b.PosX < b.Buf[b.PosY].Size()-1 {
+		b.Buf[b.PosY].Remove(b.PosX)
+		b.drawRemaining()
+	} else {
+		b.joinLines()
+	}
+}
+
+func (b *Buffer) joinLines() {
+	lineLen := b.Buf[b.PosY].Size()
+	for cnt := 0; cnt < lineLen; cnt++ {
+		r, _ := b.Buf[b.PosY].Get(0)
+		b.Buf[b.PosY].Remove(0)
+		b.Buf[b.PosY-1].Add(r)
+	}
+}
+
+func (b *Buffer) Remove() {
+	if b.PosX > 0 {
+		fmt.Print(CursorLeft + " " + CursorLeft)
+		b.PosX--
+		b.Buf[b.PosY].Remove(b.PosX)
+		if b.PosX < b.Buf[b.PosY].Size() {
+			fmt.Print(ClearToEOL)
+			b.drawRemaining()
+		}
+	} else if b.PosX == 0 && b.PosY > 0 {
+		b.joinLines()
+
+		lastPos := b.Buf[b.PosY-1].Size()
+		var cnt int
+		b.PosX = lastPos
+		b.PosY--
+
+		fmt.Print(CursorHide)
+		for {
+			if b.PosX+cnt > b.LineWidth()-5 {
+				// the concatenated line won't fit, so find the beginning of the word
+				// and copy the rest of the string from there
+				idx := b.findWordBeginning(b.PosX)
+				lineLen := b.Buf[b.PosY].Size()
+				for offset := idx + 1; offset < lineLen; offset++ {
+					r, _ := b.Buf[b.PosY].Get(idx + 1)
+					b.Buf[b.PosY].Remove(idx + 1)
+					b.Buf[b.PosY+1].Add(r)
+				}
+				// remove the trailing space
+				b.Buf[b.PosY].Remove(idx)
+				fmt.Print(CursorUp + ClearToEOL)
+				b.PosX = 0
+				b.drawRemaining()
+				fmt.Print(CursorDown)
+				if idx > 0 {
+					if lastPos-idx-1 > 0 {
+						b.PosX = lastPos - idx - 1
+						b.ResetCursor()
+					}
+				}
+				b.PosY++
+				break
+			}
+			r, ok := b.Buf[b.PosY].Get(b.PosX + cnt)
+			if !ok {
+				// found the end of the string
+				fmt.Print(CursorUp + cursorRightN(b.PosX) + ClearToEOL)
+				b.drawRemaining()
+				break
+			}
+			if r == ' ' {
+				// found the end of the word
+				lineLen := b.Buf[b.PosY].Size()
+				for offset := b.PosX + cnt + 1; offset < lineLen; offset++ {
+					r, _ := b.Buf[b.PosY].Get(b.PosX + cnt + 1)
+					b.Buf[b.PosY].Remove(b.PosX + cnt + 1)
+					b.Buf[b.PosY+1].Add(r)
+				}
+				fmt.Print(CursorUp + cursorRightN(b.PosX) + ClearToEOL)
+				b.drawRemaining()
+				break
+			}
+			cnt++
+		}
+		fmt.Print(CursorShow)
+	}
+}
+
+func (b *Buffer) RemoveBefore() {
+	for {
+		if b.PosX == 0 && b.PosY == 0 {
+			break
+		}
+		b.Remove()
+	}
+}
+
+func (b *Buffer) RemoveWordBefore() {
+	if b.PosX > 0 || b.PosY > 0 {
+		var foundNonspace bool
+		for {
+			xPos := b.PosX
+			yPos := b.PosY
+
+			v, _ := b.Buf[yPos].Get(xPos - 1)
+			if v == ' ' {
+				if !foundNonspace {
+					b.Remove()
+				} else {
+					break
+				}
+			} else {
+				foundNonspace = true
+				b.Remove()
+			}
+
+			if xPos == 0 && yPos == 0 {
+				break
+			}
+		}
+	}
+}
+
+func (b *Buffer) StringLine(x, y int) string {
+	if y >= len(b.Buf) {
+		return ""
+	}
+
+	var output string
+
+	for cnt := x; cnt < b.Buf[y].Size(); cnt++ {
+		r, _ := b.Buf[y].Get(cnt)
+		output += string(r.(rune))
+	}
+	return output
+}
+
+func (b *Buffer) String() string {
+	return b.StringFromRow(0)
+}
+
+func (b *Buffer) StringFromRow(n int) string {
+	var output []string
+	for _, row := range b.Buf[n:] {
+		var currLine string
+		for cnt := 0; cnt < row.Size(); cnt++ {
+			r, _ := row.Get(cnt)
+			currLine += string(r.(rune))
+		}
+		currLine = strings.TrimRight(currLine, " ")
+		output = append(output, currLine)
+	}
+	return strings.Join(output, "\n")
+}
+
+func (b *Buffer) cursorUp() {
+	fmt.Print(CursorUp)
+	b.ResetCursor()
+}
+
+func (b *Buffer) cursorDown() {
+	fmt.Print(CursorDown)
+	b.ResetCursor()
+}
+
+func (b *Buffer) MoveUp() {
+	if b.PosY > 0 {
+		b.PosY--
+		if b.Buf[b.PosY].Size() < b.PosX {
+			b.PosX = b.Buf[b.PosY].Size()
+		}
+		b.cursorUp()
+	} else {
+		fmt.Print("\a")
+	}
+}
+
+func (b *Buffer) MoveDown() {
+	if b.PosY < len(b.Buf)-1 {
+		b.PosY++
+		if b.Buf[b.PosY].Size() < b.PosX {
+			b.PosX = b.Buf[b.PosY].Size()
+		}
+		b.cursorDown()
+	} else {
+		fmt.Print("\a")
+	}
+}
+
+func (b *Buffer) MoveLeft() {
+	if b.PosX > 0 {
+		b.PosX--
+		fmt.Print(CursorLeft)
+	} else if b.PosY > 0 {
+		b.PosX = b.Buf[b.PosY-1].Size()
+		b.PosY--
+		b.cursorUp()
+	} else if b.PosX == 0 && b.PosY == 0 {
+		fmt.Print("\a")
+	}
+}
+
+func (b *Buffer) MoveRight() {
+	if b.PosX < b.Buf[b.PosY].Size() {
+		b.PosX++
+		fmt.Print(CursorRight)
+	} else if b.PosY < len(b.Buf)-1 {
+		b.PosY++
+		b.PosX = 0
+		b.cursorDown()
+	} else {
+		fmt.Print("\a")
+	}
+}
+
+func (b *Buffer) MoveToBOL() {
+	if b.PosX > 0 {
+		b.PosX = 0
+		b.ResetCursor()
+	}
+}
+
+func (b *Buffer) MoveToEOL() {
+	if b.PosX < b.Buf[b.PosY].Size() {
+		b.PosX = b.Buf[b.PosY].Size()
+		b.ResetCursor()
+	}
+}
+
+func (b *Buffer) MoveToEnd() {
+	fmt.Print(CursorHide)
+	yDiff := len(b.Buf)-1 - b.PosY
+	if yDiff > 0 {
+		fmt.Print(cursorDownN(yDiff))
+	}
+	b.PosY = len(b.Buf)-1
+	b.MoveToEOL()
+	fmt.Print(CursorShow)
+}
+
+func cursorLeftN(n int) string {
+	return fmt.Sprintf(CursorLeftN, n)
+}
+
+func cursorRightN(n int) string {
+	return fmt.Sprintf(CursorRightN, n)
+}
+
+func cursorUpN(n int) string {
+	return fmt.Sprintf(CursorUpN, n)
+}
+
+func cursorDownN(n int) string {
+	return fmt.Sprintf(CursorDownN, n)
+}
+
+func (b *Buffer) ClearScreen() {
+	fmt.Printf(CursorHide + ClearScreen + CursorReset + b.Prompt.Prompt)
+	if b.IsEmpty() {
+		ph := b.Prompt.Placeholder
+		fmt.Printf(ColorGrey + ph + cursorLeftN(len(ph)) + ColorDefault)
+	} else {
+		currPosX := b.PosX
+		currPosY := b.PosY
+		b.PosX = 0
+		b.PosY = 0
+		b.drawRemaining()
+		b.PosX = currPosX
+		b.PosY = currPosY
+		fmt.Print(CursorReset + cursorRightN(len(b.Prompt.Prompt)))
+		if b.PosY > 0 {
+			fmt.Print(cursorDownN(b.PosY))
+		}
+		if b.PosX > 0 {
+			fmt.Print(cursorRightN(b.PosX))
+		}
+	}
+	fmt.Print(CursorShow)
+}
+
+func (b *Buffer) IsEmpty() bool {
+	return len(b.Buf) == 1 && b.Buf[0].Empty()
+}

editor/editor.go

@@ -1,4 +1,4 @@
-package readline
+package editor
 
 import (
 	"bufio"
@@ -23,7 +23,6 @@ type Terminal struct {
 type Instance struct {
 	Prompt   *Prompt
 	Terminal *Terminal
-	History  *History
 }
 
 func New(prompt Prompt) (*Instance, error) {
@@ -32,40 +31,33 @@ func New(prompt Prompt) (*Instance, error) {
 		return nil, err
 	}
 
-	history, err := NewHistory()
-	if err != nil {
-		return nil, err
-	}
-
 	return &Instance{
 		Prompt:   &prompt,
 		Terminal: term,
-		History:  history,
 	}, nil
 }
 
-func (i *Instance) Readline() (string, error) {
+func (i *Instance) HandleInput() (string, error) {
 	prompt := i.Prompt.Prompt
 	if i.Prompt.UseAlt {
 		prompt = i.Prompt.AltPrompt
 	}
 	fmt.Print(prompt)
 
-	fd := int(syscall.Stdin)
-	termios, err := SetRawMode(fd)
+	termios, err := SetRawMode(syscall.Stdin)
 	if err != nil {
 		return "", err
 	}
-	defer UnsetRawMode(fd, termios)
+	defer UnsetRawMode(syscall.Stdin, termios)
 
 	buf, _ := NewBuffer(i.Prompt)
 
 	var esc bool
 	var escex bool
-	var metaDel bool
 	var pasteMode PasteMode
 
-	var currentLineBuf []rune
+	fmt.Print(StartBracketedPaste)
+	defer fmt.Printf(EndBracketedPaste)
 
 	for {
 		if buf.IsEmpty() {
@@ -77,33 +69,22 @@ func (i *Instance) Readline() (string, error) {
 		}
 
 		r, err := i.Terminal.Read()
+		if err != nil {
+			return "", io.EOF
+		}
 
 		if buf.IsEmpty() {
 			fmt.Print(ClearToEOL)
 		}
 
-		if err != nil {
-			return "", io.EOF
-		}
-
 		if escex {
 			escex = false
 
 			switch r {
 			case KeyUp:
-				if i.History.Pos > 0 {
-					if i.History.Pos == i.History.Size() {
-						currentLineBuf = []rune(buf.String())
-					}
-					buf.Replace(i.History.Prev())
-				}
+				buf.MoveUp()
 			case KeyDown:
-				if i.History.Pos < i.History.Size() {
-					buf.Replace(i.History.Next())
-					if i.History.Pos == i.History.Size() {
-						buf.Replace(currentLineBuf)
-					}
-				}
+				buf.MoveDown()
 			case KeyLeft:
 				buf.MoveLeft()
 			case KeyRight:
@@ -123,28 +104,16 @@ func (i *Instance) Readline() (string, error) {
 				} else if code == CharBracketedPasteEnd {
 					pasteMode = PasteModeEnd
 				}
-			case KeyDel:
-				if buf.Size() > 0 {
-					buf.Delete()
-				}
-				metaDel = true
 			case MetaStart:
-				buf.MoveToStart()
+				buf.MoveToBOL()
 			case MetaEnd:
-				buf.MoveToEnd()
-			default:
-				// skip any keys we don't know about
-				continue
+				buf.MoveToEOL()
 			}
 			continue
 		} else if esc {
 			esc = false
 
 			switch r {
-			case 'b':
-				buf.MoveLeftWord()
-			case 'f':
-				buf.MoveRightWord()
 			case CharEscapeEx:
 				escex = true
 			}
@@ -159,9 +128,9 @@ func (i *Instance) Readline() (string, error) {
 		case CharInterrupt:
 			return "", ErrInterrupt
 		case CharLineStart:
-			buf.MoveToStart()
+			buf.MoveToBOL()
 		case CharLineEnd:
-			buf.MoveToEnd()
+			buf.MoveToEOL()
 		case CharBackward:
 			buf.MoveLeft()
 		case CharForward:
@@ -169,56 +138,38 @@ func (i *Instance) Readline() (string, error) {
 		case CharBackspace, CharCtrlH:
 			buf.Remove()
 		case CharTab:
-			// todo: convert back to real tabs
 			for cnt := 0; cnt < 8; cnt++ {
 				buf.Add(' ')
 			}
 		case CharDelete:
-			if buf.Size() > 0 {
+			if len(buf.Buf) > 0 && buf.Buf[0].Size() > 0 {
 				buf.Delete()
 			} else {
 				return "", io.EOF
 			}
-		case CharKill:
-			buf.DeleteRemaining()
 		case CharCtrlU:
-			buf.DeleteBefore()
+			buf.RemoveBefore()
 		case CharCtrlL:
 			buf.ClearScreen()
 		case CharCtrlW:
-			buf.DeleteWord()
+			buf.RemoveWordBefore()
+		case CharCtrlJ:
+			buf.Add(r)
 		case CharEnter:
-			output := buf.String()
-			if output != "" {
-				i.History.Add([]rune(output))
+			if pasteMode == PasteModeStart {
+				buf.Add(r)
+				continue
 			}
 			buf.MoveToEnd()
 			fmt.Println()
-			switch pasteMode {
-			case PasteModeStart:
-				output = `"""` + output
-			case PasteModeEnd:
-				output = output + `"""`
-			}
-			return output, nil
+			return buf.String(), nil
 		default:
-			if metaDel {
-				metaDel = false
-				continue
-			}
 			if r >= CharSpace || r == CharEnter {
 				buf.Add(r)
 			}
 		}
 	}
-}
 
-func (i *Instance) HistoryEnable() {
-	i.History.Enabled = true
-}
-
-func (i *Instance) HistoryDisable() {
-	i.History.Enabled = false
 }
 
 func NewTerminal() (*Terminal, error) {

editor/errors.go

@@ -1,4 +1,4 @@
-package readline
+package editor
 
 import (
 	"errors"

editor/term.go

@@ -1,6 +1,6 @@
 //go:build aix || darwin || dragonfly || freebsd || (linux && !appengine) || netbsd || openbsd || os400 || solaris
 
-package readline
+package editor
 
 import (
 	"syscall"

editor/term_bsd.go

@@ -1,6 +1,5 @@
 //go:build darwin || freebsd || netbsd || openbsd
-
-package readline
+package editor
 
 import (
 	"syscall"

editor/term_linux.go

@@ -1,6 +1,5 @@
 //go:build linux || solaris
-
-package readline
+package editor
 
 import (
 	"syscall"

editor/types.go

@@ -1,4 +1,4 @@
-package readline
+package editor
 
 const (
 	CharNull      = 0

examples/python-json-datagenerator/predefinedschema.py

@@ -1,31 +0,0 @@
-import requests
-import json
-import random
-
-model = "llama2"
-template = {
-  "firstName": "", 
-  "lastName": "", 
-  "address": {
-    "street": "", 
-    "city": "", 
-    "state": "", 
-    "zipCode": ""
-  }, 
-  "phoneNumber": ""
-}
-
-prompt = f"generate one realistically believable sample data set of a persons first name, last name, address in the US, and  phone number. \nUse the following template: {json.dumps(template)}."
-
-data = {
-    "prompt": prompt,
-    "model": model,
-    "format": "json",
-    "stream": False,
-    "options": {"temperature": 2.5, "top_p": 0.99, "top_k": 100},
-}
-
-print(f"Generating a sample user")
-response = requests.post("http://localhost:11434/api/generate", json=data, stream=False)
-json_data = json.loads(response.text)
-print(json.dumps(json.loads(json_data["response"]), indent=2))

examples/python-json-datagenerator/randomaddresses.py

@@ -1,31 +0,0 @@
-import requests
-import json
-import random
-
-countries = [
-    "United States",
-    "United Kingdom",
-    "the Netherlands",
-    "Germany",
-    "Mexico",
-    "Canada",
-    "France",
-]
-country = random.choice(countries)
-model = "llama2"
-
-prompt = f"generate one realistically believable sample data set of a persons first name, last name, address in {country}, and phone number. Do not use common names. Respond using JSON. Key names should have no backslashes, values should use plain ascii with no special characters."
-
-data = {
-    "prompt": prompt,
-    "model": model,
-    "format": "json",
-    "stream": False,
-    "options": {"temperature": 2.5, "top_p": 0.99, "top_k": 100},
-}
-
-print(f"Generating a sample user in {country}")
-response = requests.post("http://localhost:11434/api/generate", json=data, stream=False)
-json_data = json.loads(response.text)
-
-print(json.dumps(json.loads(json_data["response"]), indent=2))

examples/python-json-datagenerator/readme.md

@@ -1,34 +0,0 @@
-# JSON Output Example
-
-![llmjson 2023-11-10 15_31_31](https://github.com/jmorganca/ollama/assets/633681/e599d986-9b4a-4118-81a4-4cfe7e22da25)
-
-There are two python scripts in this example. `randomaddresses.py` generates random addresses from different countries. `predefinedschema.py` sets a template for the model to fill in.
-
-## Review the Code
-
-Both programs are basically the same, with a different prompt for each, demonstrating two different ideas. The key part of getting JSON out of a model is to state in the prompt or system prompt that it should respond using JSON, and specifying the `format` as `json` in the data body.
-
-```python
-prompt = f"generate one realistically believable sample data set of a persons first name, last name, address in {country}, and  phone number. Do not use common names. Respond using JSON. Key names should with no backslashes, values should use plain ascii with no special characters."
-
-data = {
-    "prompt": prompt,
-    "model": model,
-    "format": "json",
-    "stream": False,
-    "options": {"temperature": 2.5, "top_p": 0.99, "top_k": 100},
-}
-```
-
-When running `randomaddresses.py` you will see that the schema changes and adapts to the chosen country.
-
-In `predefinedschema.py`, a template has been specified in the prompt as well. It's been defined as JSON and then dumped into the prompt string to make it easier to work with.
-
-Both examples turn streaming off so that we end up with the completed JSON all at once. We need to convert the `response.text` to JSON so that when we output it as a string we can set the indent spacing to make the output easy to read.
-
-```python
-response = requests.post("http://localhost:11434/api/generate", json=data, stream=False)
-json_data = json.loads(response.text)
-
-print(json.dumps(json.loads(json_data["response"]), indent=2))
-```

examples/python-json-datagenerator/requirements.txt

@@ -1 +0,0 @@
-Requests==2.31.0

examples/python-loganalysis/Modelfile

@@ -1,8 +0,0 @@
-FROM codebooga:latest
-
-SYSTEM """
-You are a log file analyzer. You will receive a set of lines from a log file for some software application, find the errors and other interesting aspects of the logs, and explain them so a new user can understand what they mean. If there are any steps they can do to resolve them, list the steps in your answer.
-"""
-
-PARAMETER TEMPERATURE 0.3
-

examples/python-loganalysis/loganalysis.py

@@ -1,42 +0,0 @@
-import sys
-import re
-import requests
-import json
-
-# prelines and postlines represent the number of lines of context to include in the output around the error
-prelines = 10
-postlines = 10
-
-def find_errors_in_log_file():
-  if len(sys.argv) < 2:
-    print("Usage: python loganalysis.py <filename>")
-    return
-
-  log_file_path = sys.argv[1]
-  with open(log_file_path, 'r') as log_file:
-    log_lines = log_file.readlines()
-
-error_logs = []
-    for i, line in enumerate(log_lines):
-        if "error" in line.lower():
-            start_index = max(0, i - prelines)
-            end_index = min(len(log_lines), i + postlines + 1)
-            error_logs.extend(log_lines[start_index:end_index])
-
-  return error_logs
-
-error_logs = find_errors_in_log_file()
-
-data = {
-  "prompt": "\n".join(error_logs), 
-  "model": "mattw/loganalyzer"
-}
-
-
-response = requests.post("http://localhost:11434/api/generate", json=data, stream=True)
-for line in response.iter_lines():
-  if line:
-    json_data = json.loads(line)
-    if json_data['done'] == False:
-      print(json_data['response'], end='', flush=True)
-

examples/python-loganalysis/logtest.logfile

@@ -1,32 +0,0 @@
-2023-11-10 07:17:40 /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
-2023-11-10 07:17:40 /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
-2023-11-10 07:17:40 /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
-2023-11-10 07:17:40 10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
-2023-11-10 07:17:40 10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
-2023-11-10 07:17:40 /docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
-2023-11-10 07:17:40 /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
-2023-11-10 07:17:40 /docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
-2023-11-10 07:17:40 /docker-entrypoint.sh: Configuration complete; ready for start up
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: using the "epoll" event method
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: nginx/1.25.3
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14) 
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: OS: Linux 6.4.16-linuxkit
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker processes
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 29
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 30
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 31
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 32
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 33
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 34
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 35
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 36
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 37
-2023-11-10 07:17:40 2023/11/10 13:17:40 [notice] 1#1: start worker process 38
-2023-11-10 07:17:44 192.168.65.1 - - [10/Nov/2023:13:17:43 +0000] "GET / HTTP/1.1" 200 615 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36" "-"
-2023-11-10 07:17:44 2023/11/10 13:17:44 [error] 29#29: *1 open() "/usr/share/nginx/html/favicon.ico" failed (2: No such file or directory), client: 192.168.65.1, server: localhost, request: "GET /favicon.ico HTTP/1.1", host: "localhost:8080", referrer: "http://localhost:8080/"
-2023-11-10 07:17:44 192.168.65.1 - - [10/Nov/2023:13:17:44 +0000] "GET /favicon.ico HTTP/1.1" 404 555 "http://localhost:8080/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36" "-"
-2023-11-10 07:17:50 2023/11/10 13:17:50 [error] 29#29: *1 open() "/usr/share/nginx/html/ahstat" failed (2: No such file or directory), client: 192.168.65.1, server: localhost, request: "GET /ahstat HTTP/1.1", host: "localhost:8080"
-2023-11-10 07:17:50 192.168.65.1 - - [10/Nov/2023:13:17:50 +0000] "GET /ahstat HTTP/1.1" 404 555 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36" "-"
-2023-11-10 07:18:53 2023/11/10 13:18:53 [error] 29#29: *1 open() "/usr/share/nginx/html/ahstat" failed (2: No such file or directory), client: 192.168.65.1, server: localhost, request: "GET /ahstat HTTP/1.1", host: "localhost:8080"
-2023-11-10 07:18:53 192.168.65.1 - - [10/Nov/2023:13:18:53 +0000] "GET /ahstat HTTP/1.1" 404 555 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36" "-"

examples/python-loganalysis/readme.md

@@ -1,48 +0,0 @@
-# Log Analysis example
-
-![loganalyzer 2023-11-10 08_53_29](https://github.com/jmorganca/ollama/assets/633681/ad30f1fc-321f-4953-8914-e30e24db9921)
-
-This example shows one possible way to create a log file analyzer. To use it, run:
-
-`python loganalysis.py <logfile>`
-
-You can try this with the `logtest.logfile` file included in this directory.
-
-## Review the code
-
-The first part of this example is a Modelfile that takes `codebooga` and applies a new System Prompt:
-
-```plaintext
-SYSTEM """
-You are a log file analyzer. You will receive a set of lines from a log file for some software application, find the errors and other interesting aspects of the logs, and explain them so a new user can understand what they mean. If there are any steps they can do to resolve them, list the steps in your answer.
-"""
-```
-
-This model is available at https://ollama.ai/mattw/loganalyzer. You can customize it and add to your own namespace using the command `ollama create <namespace/modelname> -f <path-to-modelfile>` then `ollama push <namespace/modelname>`.
-
-Then loganalysis.py scans all the lines in the given log file and searches for the word 'error'. When the word is found, the 10 lines before and after are set as the prompt for a call to the Generate API.
-
-```python
-data = {
-  "prompt": "\n".join(error_logs), 
-  "model": "mattw/loganalyzer"
-}
-```
-
-Finally, the streamed output is parsed and the response field in the output is printed to the line.
-
-```python
-response = requests.post("http://localhost:11434/api/generate", json=data, stream=True)
-for line in response.iter_lines():
-  if line:
-    json_data = json.loads(line)
-    if json_data['done'] == False:
-      print(json_data['response'], end='')
-
-```
-
-## Next Steps
-
-There is a lot more that can be done here. This is a simple way to detect errors, looking for the word error. Perhaps it would be interesting to find anomalous activity in the logs. It could be interesting to create embeddings for each line and compare them, looking for similar lines. Or look into applying Levenshtein Distance algorithms to find similar lines to help identify the anomalous lines.
-
-Also try different models and different prompts to analyze the data. You could consider adding retrieval augmented generation (RAG) to this to help understand newer log formats.

examples/python-loganalysis/requirements.txt

@@ -1 +0,0 @@
-Requests==2.31.0

format/bytes.go

@@ -12,11 +12,11 @@ const (
 func HumanBytes(b int64) string {
 	switch {
 	case b > GigaByte:
-		return fmt.Sprintf("%.1f GB", float64(b)/GigaByte)
+		return fmt.Sprintf("%d GB", b/GigaByte)
 	case b > MegaByte:
-		return fmt.Sprintf("%.1f MB", float64(b)/MegaByte)
+		return fmt.Sprintf("%d MB", b/MegaByte)
 	case b > KiloByte:
-		return fmt.Sprintf("%.1f KB", float64(b)/KiloByte)
+		return fmt.Sprintf("%d KB", b/KiloByte)
 	default:
 		return fmt.Sprintf("%d B", b)
 	}

go.mod

@@ -3,6 +3,7 @@ module github.com/jmorganca/ollama
 go 1.20
 
 require (
+	github.com/dustin/go-humanize v1.0.1
 	github.com/emirpasic/gods v1.18.1
 	github.com/gin-gonic/gin v1.9.1
 	github.com/mattn/go-runewidth v0.0.14

go.sum

@@ -9,6 +9,8 @@ github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ3
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=

llm/llama.cpp/generate_darwin_amd64.go

@@ -14,6 +14,6 @@ package llm
 //go:generate git submodule update --force gguf
 //go:generate git -C gguf apply ../patches/0001-update-default-log-target.patch
 //go:generate git -C gguf apply ../patches/0001-metal-handle-ggml_scale-for-n-4-0-close-3754.patch
-//go:generate cmake -S gguf -B gguf/build/cpu -DLLAMA_METAL=off -DLLAMA_ACCELERATE=on -DLLAMA_K_QUANTS=on -DCMAKE_SYSTEM_PROCESSOR=x86_64 -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 -DLLAMA_NATIVE=off -DLLAMA_AVX=on -DLLAMA_AVX2=off -DLLAMA_AVX512=off -DLLAMA_FMA=off -DLLAMA_F16C=off
+//go:generate cmake -S gguf -B gguf/build/cpu -DLLAMA_ACCELERATE=on -DLLAMA_K_QUANTS=on -DCMAKE_SYSTEM_PROCESSOR=x86_64 -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0
 //go:generate cmake --build gguf/build/cpu --target server --config Release
 //go:generate mv gguf/build/cpu/bin/server gguf/build/cpu/bin/ollama-runner

llm/llama.go

@@ -71,10 +71,9 @@ func chooseRunners(workDir, runnerType string) []ModelRunner {
 	// IMPORTANT: the order of the runners in the array is the priority order
 	switch runtime.GOOS {
 	case "darwin":
-		if runtime.GOARCH == "arm64" {
-			runners = []ModelRunner{{Path: path.Join(buildPath, "metal", "bin", "ollama-runner")}}
-		} else {
-			runners = []ModelRunner{{Path: path.Join(buildPath, "cpu", "bin", "ollama-runner")}}
+		runners = []ModelRunner{
+			{Path: path.Join(buildPath, "metal", "bin", "ollama-runner")},
+			{Path: path.Join(buildPath, "cpu", "bin", "ollama-runner")},
 		}
 	case "linux":
 		runners = []ModelRunner{

readline/buffer.go

@@ -1,372 +0,0 @@
-package readline
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/emirpasic/gods/lists/arraylist"
-	"golang.org/x/term"
-)
-
-type Buffer struct {
-	Pos       int
-	Buf       *arraylist.List
-	Prompt    *Prompt
-	LineWidth int
-	Width     int
-	Height    int
-}
-
-func NewBuffer(prompt *Prompt) (*Buffer, error) {
-	fd := int(os.Stdout.Fd())
-	width, height, err := term.GetSize(fd)
-	if err != nil {
-		fmt.Println("Error getting size:", err)
-		return nil, err
-	}
-
-	lwidth := width - len(prompt.Prompt)
-	if prompt.UseAlt {
-		lwidth = width - len(prompt.AltPrompt)
-	}
-
-	b := &Buffer{
-		Pos:       0,
-		Buf:       arraylist.New(),
-		Prompt:    prompt,
-		Width:     width,
-		Height:    height,
-		LineWidth: lwidth,
-	}
-
-	return b, nil
-}
-
-func (b *Buffer) MoveLeft() {
-	if b.Pos > 0 {
-		if b.Pos%b.LineWidth == 0 {
-			fmt.Printf(CursorUp + CursorBOL + cursorRightN(b.Width))
-		} else {
-			fmt.Print(CursorLeft)
-		}
-		b.Pos -= 1
-	}
-}
-
-func (b *Buffer) MoveLeftWord() {
-	if b.Pos > 0 {
-		var foundNonspace bool
-		for {
-			v, _ := b.Buf.Get(b.Pos - 1)
-			if v == ' ' {
-				if foundNonspace {
-					break
-				}
-			} else {
-				foundNonspace = true
-			}
-			b.MoveLeft()
-
-			if b.Pos == 0 {
-				break
-			}
-		}
-	}
-}
-
-func (b *Buffer) MoveRight() {
-	if b.Pos < b.Size() {
-		b.Pos += 1
-		if b.Pos%b.LineWidth == 0 {
-			fmt.Printf(CursorDown + CursorBOL + cursorRightN(b.PromptSize()))
-		} else {
-			fmt.Print(CursorRight)
-		}
-	}
-}
-
-func (b *Buffer) MoveRightWord() {
-	if b.Pos < b.Size() {
-		for {
-			b.MoveRight()
-			v, _ := b.Buf.Get(b.Pos)
-			if v == ' ' {
-				break
-			}
-
-			if b.Pos == b.Size() {
-				break
-			}
-		}
-	}
-}
-
-func (b *Buffer) MoveToStart() {
-	if b.Pos > 0 {
-		currLine := b.Pos / b.LineWidth
-		if currLine > 0 {
-			for cnt := 0; cnt < currLine; cnt++ {
-				fmt.Print(CursorUp)
-			}
-		}
-		fmt.Printf(CursorBOL + cursorRightN(b.PromptSize()))
-		b.Pos = 0
-	}
-}
-
-func (b *Buffer) MoveToEnd() {
-	if b.Pos < b.Size() {
-		currLine := b.Pos / b.LineWidth
-		totalLines := b.Size() / b.LineWidth
-		if currLine < totalLines {
-			for cnt := 0; cnt < totalLines-currLine; cnt++ {
-				fmt.Print(CursorDown)
-			}
-			remainder := b.Size() % b.LineWidth
-			fmt.Printf(CursorBOL + cursorRightN(b.PromptSize()+remainder))
-		} else {
-			fmt.Print(cursorRightN(b.Size() - b.Pos))
-		}
-
-		b.Pos = b.Size()
-	}
-}
-
-func (b *Buffer) Size() int {
-	return b.Buf.Size()
-}
-
-func min(n, m int) int {
-	if n > m {
-		return m
-	}
-	return n
-}
-
-func (b *Buffer) PromptSize() int {
-	if b.Prompt.UseAlt {
-		return len(b.Prompt.AltPrompt)
-	}
-	return len(b.Prompt.Prompt)
-}
-
-func (b *Buffer) Add(r rune) {
-	if b.Pos == b.Buf.Size() {
-		fmt.Printf("%c", r)
-		b.Buf.Add(r)
-		b.Pos += 1
-		if b.Pos > 0 && b.Pos%b.LineWidth == 0 {
-			fmt.Printf("\n%s", b.Prompt.AltPrompt)
-		}
-	} else {
-		fmt.Printf("%c", r)
-		b.Buf.Insert(b.Pos, r)
-		b.Pos += 1
-		if b.Pos > 0 && b.Pos%b.LineWidth == 0 {
-			fmt.Printf("\n%s", b.Prompt.AltPrompt)
-		}
-		b.drawRemaining()
-	}
-}
-
-func (b *Buffer) drawRemaining() {
-	var place int
-	remainingText := b.StringN(b.Pos)
-	if b.Pos > 0 {
-		place = b.Pos % b.LineWidth
-	}
-	fmt.Print(CursorHide)
-
-	// render the rest of the current line
-	currLine := remainingText[:min(b.LineWidth-place, len(remainingText))]
-	if len(currLine) > 0 {
-		fmt.Printf(ClearToEOL + currLine)
-		fmt.Print(cursorLeftN(len(currLine)))
-	} else {
-		fmt.Print(ClearToEOL)
-	}
-
-	// render the other lines
-	if len(remainingText) > len(currLine) {
-		remaining := []rune(remainingText[len(currLine):])
-		var totalLines int
-		for i, c := range remaining {
-			if i%b.LineWidth == 0 {
-				fmt.Printf("\n%s", b.Prompt.AltPrompt)
-				totalLines += 1
-			}
-			fmt.Printf("%c", c)
-		}
-		fmt.Print(ClearToEOL)
-		fmt.Print(cursorUpN(totalLines))
-		fmt.Printf(CursorBOL + cursorRightN(b.Width-len(currLine)))
-	}
-
-	fmt.Print(CursorShow)
-}
-
-func (b *Buffer) Remove() {
-	if b.Buf.Size() > 0 && b.Pos > 0 {
-		if b.Pos%b.LineWidth == 0 {
-			// if the user backspaces over the word boundary, do this magic to clear the line
-			// and move to the end of the previous line
-			fmt.Printf(CursorBOL + ClearToEOL)
-			fmt.Printf(CursorUp + CursorBOL + cursorRightN(b.Width) + " " + CursorLeft)
-		} else {
-			fmt.Printf(CursorLeft + " " + CursorLeft)
-		}
-
-		var eraseExtraLine bool
-		if (b.Size()-1)%b.LineWidth == 0 {
-			eraseExtraLine = true
-		}
-
-		b.Pos -= 1
-		b.Buf.Remove(b.Pos)
-
-		if b.Pos < b.Size() {
-			b.drawRemaining()
-			// this erases a line which is left over when backspacing in the middle of a line and there
-			// are trailing characters which go over the line width boundary
-			if eraseExtraLine {
-				remainingLines := (b.Size() - b.Pos) / b.LineWidth
-				fmt.Printf(cursorDownN(remainingLines+1) + CursorBOL + ClearToEOL)
-				place := b.Pos % b.LineWidth
-				fmt.Printf(cursorUpN(remainingLines+1) + cursorRightN(place+len(b.Prompt.Prompt)))
-			}
-		}
-	}
-}
-
-func (b *Buffer) Delete() {
-	if b.Size() > 0 && b.Pos < b.Size() {
-		b.Buf.Remove(b.Pos)
-		b.drawRemaining()
-		if b.Size()%b.LineWidth == 0 {
-			if b.Pos != b.Size() {
-				remainingLines := (b.Size() - b.Pos) / b.LineWidth
-				fmt.Printf(cursorDownN(remainingLines) + CursorBOL + ClearToEOL)
-				place := b.Pos % b.LineWidth
-				fmt.Printf(cursorUpN(remainingLines) + cursorRightN(place+len(b.Prompt.Prompt)))
-			}
-		}
-	}
-}
-
-func (b *Buffer) DeleteBefore() {
-	if b.Pos > 0 {
-		for cnt := b.Pos - 1; cnt >= 0; cnt-- {
-			b.Remove()
-		}
-	}
-}
-
-func (b *Buffer) DeleteRemaining() {
-	if b.Size() > 0 && b.Pos < b.Size() {
-		charsToDel := b.Size() - b.Pos
-		for cnt := 0; cnt < charsToDel; cnt++ {
-			b.Delete()
-		}
-	}
-}
-
-func (b *Buffer) DeleteWord() {
-	if b.Buf.Size() > 0 && b.Pos > 0 {
-		var foundNonspace bool
-		for {
-			v, _ := b.Buf.Get(b.Pos - 1)
-			if v == ' ' {
-				if !foundNonspace {
-					b.Remove()
-				} else {
-					break
-				}
-			} else {
-				foundNonspace = true
-				b.Remove()
-			}
-
-			if b.Pos == 0 {
-				break
-			}
-		}
-	}
-}
-
-func (b *Buffer) ClearScreen() {
-	fmt.Printf(ClearScreen + CursorReset + b.Prompt.Prompt)
-	if b.IsEmpty() {
-		ph := b.Prompt.Placeholder
-		fmt.Printf(ColorGrey + ph + cursorLeftN(len(ph)) + ColorDefault)
-	} else {
-		currPos := b.Pos
-		b.Pos = 0
-		b.drawRemaining()
-		fmt.Printf(CursorReset + cursorRightN(len(b.Prompt.Prompt)))
-		if currPos > 0 {
-			targetLine := currPos / b.LineWidth
-			if targetLine > 0 {
-				for cnt := 0; cnt < targetLine; cnt++ {
-					fmt.Print(CursorDown)
-				}
-			}
-			remainder := currPos % b.LineWidth
-			if remainder > 0 {
-				fmt.Print(cursorRightN(remainder))
-			}
-			if currPos%b.LineWidth == 0 {
-				fmt.Printf(CursorBOL + b.Prompt.AltPrompt)
-			}
-		}
-		b.Pos = currPos
-	}
-}
-
-func (b *Buffer) IsEmpty() bool {
-	return b.Buf.Empty()
-}
-
-func (b *Buffer) Replace(r []rune) {
-	b.Pos = 0
-	b.Buf.Clear()
-	fmt.Printf(ClearLine + CursorBOL + b.Prompt.Prompt)
-	for _, c := range r {
-		b.Add(c)
-	}
-}
-
-func (b *Buffer) String() string {
-	return b.StringN(0)
-}
-
-func (b *Buffer) StringN(n int) string {
-	return b.StringNM(n, 0)
-}
-
-func (b *Buffer) StringNM(n, m int) string {
-	var s string
-	if m == 0 {
-		m = b.Size()
-	}
-	for cnt := n; cnt < m; cnt++ {
-		c, _ := b.Buf.Get(cnt)
-		s += string(c.(rune))
-	}
-	return s
-}
-
-func cursorLeftN(n int) string {
-	return fmt.Sprintf(CursorLeftN, n)
-}
-
-func cursorRightN(n int) string {
-	return fmt.Sprintf(CursorRightN, n)
-}
-
-func cursorUpN(n int) string {
-	return fmt.Sprintf(CursorUpN, n)
-}
-
-func cursorDownN(n int) string {
-	return fmt.Sprintf(CursorDownN, n)
-}

readline/history.go

@@ -1,152 +0,0 @@
-package readline
-
-import (
-	"bufio"
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/emirpasic/gods/lists/arraylist"
-)
-
-type History struct {
-	Buf      *arraylist.List
-	Autosave bool
-	Pos      int
-	Limit    int
-	Filename string
-	Enabled  bool
-}
-
-func NewHistory() (*History, error) {
-	h := &History{
-		Buf:      arraylist.New(),
-		Limit:    100, //resizeme
-		Autosave: true,
-		Enabled:  true,
-	}
-
-	err := h.Init()
-	if err != nil {
-		return nil, err
-	}
-
-	return h, nil
-}
-
-func (h *History) Init() error {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return err
-	}
-
-	path := filepath.Join(home, ".ollama", "history")
-	h.Filename = path
-
-	//todo check if the file exists
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_RDONLY, 0600)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil
-		}
-		return err
-	}
-	defer f.Close()
-
-	r := bufio.NewReader(f)
-	for {
-		line, err := r.ReadString('\n')
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return err
-		}
-
-		line = strings.TrimSpace(line)
-		if len(line) == 0 {
-			continue
-		}
-
-		h.Add([]rune(line))
-	}
-
-	return nil
-}
-
-func (h *History) Add(l []rune) {
-	h.Buf.Add(l)
-	h.Compact()
-	h.Pos = h.Size()
-	if h.Autosave {
-		h.Save()
-	}
-}
-
-func (h *History) Compact() {
-	s := h.Buf.Size()
-	if s > h.Limit {
-		for cnt := 0; cnt < s-h.Limit; cnt++ {
-			h.Buf.Remove(0)
-		}
-	}
-}
-
-func (h *History) Clear() {
-	h.Buf.Clear()
-}
-
-func (h *History) Prev() []rune {
-	var line []rune
-	if h.Pos > 0 {
-		h.Pos -= 1
-	}
-	v, _ := h.Buf.Get(h.Pos)
-	line, _ = v.([]rune)
-	return line
-}
-
-func (h *History) Next() []rune {
-	var line []rune
-	if h.Pos < h.Buf.Size() {
-		h.Pos += 1
-		v, _ := h.Buf.Get(h.Pos)
-		line, _ = v.([]rune)
-	}
-	return line
-}
-
-func (h *History) Size() int {
-	return h.Buf.Size()
-}
-
-func (h *History) Save() error {
-	if !h.Enabled {
-		return nil
-	}
-
-	tmpFile := h.Filename + ".tmp"
-
-	f, err := os.OpenFile(tmpFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC|os.O_APPEND, 0666)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	buf := bufio.NewWriter(f)
-	for cnt := 0; cnt < h.Size(); cnt++ {
-		v, _ := h.Buf.Get(cnt)
-		line, _ := v.([]rune)
-		buf.WriteString(string(line) + "\n")
-	}
-	buf.Flush()
-	f.Close()
-
-	if err = os.Rename(tmpFile, h.Filename); err != nil {
-		return err
-	}
-
-	return nil
-}

scripts/build_darwin.sh

@@ -10,7 +10,6 @@ mkdir -p dist
 for TARGETARCH in arm64 amd64; do
     GOOS=darwin GOARCH=$TARGETARCH go generate ./...
     GOOS=darwin GOARCH=$TARGETARCH go build -o dist/ollama-darwin-$TARGETARCH
-    rm -rf llm/llama.cpp/*/build
 done
 
 lipo -create -output dist/ollama dist/ollama-darwin-*

scripts/install.sh

@@ -181,9 +181,6 @@ install_cuda_driver_apt() {
         debian)
             status 'Enabling contrib sources...'
             $SUDO sed 's/main/contrib/' < /etc/apt/sources.list | $SUDO tee /etc/apt/sources.list.d/contrib.list > /dev/null
-            if [ -f "/etc/apt/sources.list.d/debian.sources" ]; then
-                $SUDO sed 's/main/contrib/' < /etc/apt/sources.list.d/debian.sources | $SUDO tee /etc/apt/sources.list.d/contrib.sources > /dev/null
-            fi
             ;;
     esac
 

server/images.go

@@ -248,181 +248,200 @@ func filenameWithPath(path, f string) (string, error) {
 	return f, nil
 }
 
-func realpath(p string) string {
-	abspath, err := filepath.Abs(p)
+func CreateModel(ctx context.Context, name string, path string, fn func(resp api.ProgressResponse)) error {
+	mp := ParseModelPath(name)
+
+	var manifest *ManifestV2
+	var err error
+	var noprune string
+
+	// build deleteMap to prune unused layers
+	deleteMap := make(map[string]bool)
+
+	if noprune = os.Getenv("OLLAMA_NOPRUNE"); noprune == "" {
+		manifest, _, err = GetManifest(mp)
+		if err != nil && !errors.Is(err, os.ErrNotExist) {
+			return err
+		}
+
+		if manifest != nil {
+			for _, l := range manifest.Layers {
+				deleteMap[l.Digest] = true
+			}
+			deleteMap[manifest.Config.Digest] = true
+		}
+	}
+
+	mf, err := os.Open(path)
 	if err != nil {
-		return p
+		fn(api.ProgressResponse{Status: fmt.Sprintf("couldn't open modelfile '%s'", path)})
+		return fmt.Errorf("failed to open file: %w", err)
 	}
+	defer mf.Close()
 
-	home, err := os.UserHomeDir()
+	fn(api.ProgressResponse{Status: "parsing modelfile"})
+	commands, err := parser.Parse(mf)
 	if err != nil {
-		return abspath
+		return err
 	}
 
-	if p == "~" {
-		return home
-	} else if strings.HasPrefix(p, "~/") {
-		return filepath.Join(home, p[2:])
-	}
-
-	return abspath
-}
-
-func CreateModel(ctx context.Context, name string, commands []parser.Command, fn func(resp api.ProgressResponse)) error {
 	config := ConfigV2{
-		OS:           "linux",
 		Architecture: "amd64",
+		OS:           "linux",
 	}
 
-	deleteMap := make(map[string]struct{})
-
 	var layers []*LayerReader
-
 	params := make(map[string][]string)
-	fromParams := make(map[string]any)
-
+	var sourceParams map[string]any
 	for _, c := range commands {
-		log.Printf("[%s] - %s", c.Name, c.Args)
-		mediatype := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)
-
+		log.Printf("[%s] - %s\n", c.Name, c.Args)
 		switch c.Name {
 		case "model":
-			if strings.HasPrefix(c.Args, "@") {
-				blobPath, err := GetBlobsPath(strings.TrimPrefix(c.Args, "@"))
+			fn(api.ProgressResponse{Status: "looking for model"})
+
+			mp := ParseModelPath(c.Args)
+			mf, _, err := GetManifest(mp)
+			if err != nil {
+				modelFile, err := filenameWithPath(path, c.Args)
 				if err != nil {
 					return err
 				}
-
-				c.Args = blobPath
-			}
-
-			bin, err := os.Open(realpath(c.Args))
-			if err != nil {
-				// not a file on disk so must be a model reference
-				modelpath := ParseModelPath(c.Args)
-				manifest, _, err := GetManifest(modelpath)
-				switch {
-				case errors.Is(err, os.ErrNotExist):
-					fn(api.ProgressResponse{Status: "pulling model"})
-					if err := PullModel(ctx, c.Args, &RegistryOptions{}, fn); err != nil {
+				if _, err := os.Stat(modelFile); err != nil {
+					// the model file does not exist, try pulling it
+					if errors.Is(err, os.ErrNotExist) {
+						fn(api.ProgressResponse{Status: "pulling model file"})
+						if err := PullModel(ctx, c.Args, &RegistryOptions{}, fn); err != nil {
+							return err
+						}
+						mf, _, err = GetManifest(mp)
+						if err != nil {
+							return fmt.Errorf("failed to open file after pull: %v", err)
+						}
+					} else {
 						return err
 					}
+				} else {
+					// create a model from this specified file
+					fn(api.ProgressResponse{Status: "creating model layer"})
+					file, err := os.Open(modelFile)
+					if err != nil {
+						return fmt.Errorf("failed to open file: %v", err)
+					}
+					defer file.Close()
 
-					manifest, _, err = GetManifest(modelpath)
+					ggml, err := llm.DecodeGGML(file)
 					if err != nil {
 						return err
 					}
-				case err != nil:
-					return err
-				}
 
+					config.ModelFormat = ggml.Name()
+					config.ModelFamily = ggml.ModelFamily()
+					config.ModelType = ggml.ModelType()
+					config.FileType = ggml.FileType()
+
+					// reset the file
+					file.Seek(0, io.SeekStart)
+
+					l, err := CreateLayer(file)
+					if err != nil {
+						return fmt.Errorf("failed to create layer: %v", err)
+					}
+					l.MediaType = "application/vnd.ollama.image.model"
+					layers = append(layers, l)
+				}
+			}
+
+			if mf != nil {
 				fn(api.ProgressResponse{Status: "reading model metadata"})
-				fromConfigPath, err := GetBlobsPath(manifest.Config.Digest)
+				sourceBlobPath, err := GetBlobsPath(mf.Config.Digest)
 				if err != nil {
 					return err
 				}
 
-				fromConfigFile, err := os.Open(fromConfigPath)
+				sourceBlob, err := os.Open(sourceBlobPath)
 				if err != nil {
 					return err
 				}
-				defer fromConfigFile.Close()
+				defer sourceBlob.Close()
 
-				var fromConfig ConfigV2
-				if err := json.NewDecoder(fromConfigFile).Decode(&fromConfig); err != nil {
+				var source ConfigV2
+				if err := json.NewDecoder(sourceBlob).Decode(&source); err != nil {
 					return err
 				}
 
-				config.ModelFormat = fromConfig.ModelFormat
-				config.ModelFamily = fromConfig.ModelFamily
-				config.ModelType = fromConfig.ModelType
-				config.FileType = fromConfig.FileType
+				// copy the model metadata
+				config.ModelFamily = source.ModelFamily
+				config.ModelType = source.ModelType
+				config.ModelFormat = source.ModelFormat
+				config.FileType = source.FileType
 
-				for _, layer := range manifest.Layers {
-					deleteMap[layer.Digest] = struct{}{}
-					if layer.MediaType == "application/vnd.ollama.image.params" {
-						fromParamsPath, err := GetBlobsPath(layer.Digest)
+				for _, l := range mf.Layers {
+					if l.MediaType == "application/vnd.ollama.image.params" {
+						sourceParamsBlobPath, err := GetBlobsPath(l.Digest)
 						if err != nil {
 							return err
 						}
 
-						fromParamsFile, err := os.Open(fromParamsPath)
+						sourceParamsBlob, err := os.Open(sourceParamsBlobPath)
 						if err != nil {
 							return err
 						}
-						defer fromParamsFile.Close()
+						defer sourceParamsBlob.Close()
 
-						if err := json.NewDecoder(fromParamsFile).Decode(&fromParams); err != nil {
+						if err := json.NewDecoder(sourceParamsBlob).Decode(&sourceParams); err != nil {
 							return err
 						}
 					}
 
-					layer, err := GetLayerWithBufferFromLayer(layer)
+					newLayer, err := GetLayerWithBufferFromLayer(l)
 					if err != nil {
 						return err
 					}
-
-					layer.From = modelpath.GetShortTagname()
-					layers = append(layers, layer)
+					newLayer.From = mp.GetShortTagname()
+					layers = append(layers, newLayer)
 				}
-
-				deleteMap[manifest.Config.Digest] = struct{}{}
-				continue
 			}
-			defer bin.Close()
-
-			fn(api.ProgressResponse{Status: "creating model layer"})
-			ggml, err := llm.DecodeGGML(bin)
-			if err != nil {
-				return err
-			}
-
-			config.ModelFormat = ggml.Name()
-			config.ModelFamily = ggml.ModelFamily()
-			config.ModelType = ggml.ModelType()
-			config.FileType = ggml.FileType()
-
-			bin.Seek(0, io.SeekStart)
-			layer, err := CreateLayer(bin)
-			if err != nil {
-				return err
-			}
-
-			layer.MediaType = mediatype
-			layers = append(layers, layer)
 		case "adapter":
-			fn(api.ProgressResponse{Status: "creating adapter layer"})
-			bin, err := os.Open(realpath(c.Args))
-			if err != nil {
-				return err
-			}
-			defer bin.Close()
+			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
 
-			layer, err := CreateLayer(bin)
+			fp, err := filenameWithPath(path, c.Args)
 			if err != nil {
 				return err
 			}
 
-			if layer.Size > 0 {
-				layer.MediaType = mediatype
-				layers = append(layers, layer)
+			// create a model from this specified file
+			fn(api.ProgressResponse{Status: "creating model layer"})
+
+			file, err := os.Open(fp)
+			if err != nil {
+				return fmt.Errorf("failed to open file: %v", err)
 			}
+			defer file.Close()
+
+			l, err := CreateLayer(file)
+			if err != nil {
+				return fmt.Errorf("failed to create layer: %v", err)
+			}
+			l.MediaType = "application/vnd.ollama.image.adapter"
+			layers = append(layers, l)
 		case "license":
-			fn(api.ProgressResponse{Status: "creating license layer"})
+			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
+			mediaType := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)
+
 			layer, err := CreateLayer(strings.NewReader(c.Args))
 			if err != nil {
 				return err
 			}
 
 			if layer.Size > 0 {
-				layer.MediaType = mediatype
+				layer.MediaType = mediaType
 				layers = append(layers, layer)
 			}
-		case "template", "system":
-			fn(api.ProgressResponse{Status: fmt.Sprintf("creating %s layer", c.Name)})
-
-			// remove duplicate layers
-			layers = removeLayerFromLayers(layers, mediatype)
+		case "template", "system", "prompt":
+			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
+			// remove the layer if one exists
+			mediaType := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)
+			layers = removeLayerFromLayers(layers, mediaType)
 
 			layer, err := CreateLayer(strings.NewReader(c.Args))
 			if err != nil {
@@ -430,47 +449,48 @@ func CreateModel(ctx context.Context, name string, commands []parser.Command, fn
 			}
 
 			if layer.Size > 0 {
-				layer.MediaType = mediatype
+				layer.MediaType = mediaType
 				layers = append(layers, layer)
 			}
 		default:
+			// runtime parameters, build a list of args for each parameter to allow multiple values to be specified (ex: multiple stop sequences)
 			params[c.Name] = append(params[c.Name], c.Args)
 		}
 	}
 
+	// Create a single layer for the parameters
 	if len(params) > 0 {
-		fn(api.ProgressResponse{Status: "creating parameters layer"})
+		fn(api.ProgressResponse{Status: "creating parameter layer"})
 
+		layers = removeLayerFromLayers(layers, "application/vnd.ollama.image.params")
 		formattedParams, err := formatParams(params)
 		if err != nil {
-			return err
+			return fmt.Errorf("couldn't create params json: %v", err)
 		}
 
-		for k, v := range fromParams {
+		for k, v := range sourceParams {
 			if _, ok := formattedParams[k]; !ok {
 				formattedParams[k] = v
 			}
 		}
 
 		if config.ModelType == "65B" {
-			if gqa, ok := formattedParams["gqa"].(int); ok && gqa == 8 {
+			if numGQA, ok := formattedParams["num_gqa"].(int); ok && numGQA == 8 {
 				config.ModelType = "70B"
 			}
 		}
 
-		var b bytes.Buffer
-		if err := json.NewEncoder(&b).Encode(formattedParams); err != nil {
-			return err
-		}
-
-		fn(api.ProgressResponse{Status: "creating config layer"})
-		layer, err := CreateLayer(bytes.NewReader(b.Bytes()))
+		bts, err := json.Marshal(formattedParams)
 		if err != nil {
 			return err
 		}
 
-		layer.MediaType = "application/vnd.ollama.image.params"
-		layers = append(layers, layer)
+		l, err := CreateLayer(bytes.NewReader(bts))
+		if err != nil {
+			return fmt.Errorf("failed to create layer: %v", err)
+		}
+		l.MediaType = "application/vnd.ollama.image.params"
+		layers = append(layers, l)
 	}
 
 	digests, err := getLayerDigests(layers)
@@ -478,31 +498,36 @@ func CreateModel(ctx context.Context, name string, commands []parser.Command, fn
 		return err
 	}
 
-	configLayer, err := createConfigLayer(config, digests)
+	var manifestLayers []*Layer
+	for _, l := range layers {
+		manifestLayers = append(manifestLayers, &l.Layer)
+		delete(deleteMap, l.Layer.Digest)
+	}
+
+	// Create a layer for the config object
+	fn(api.ProgressResponse{Status: "creating config layer"})
+	cfg, err := createConfigLayer(config, digests)
 	if err != nil {
 		return err
 	}
-
-	layers = append(layers, configLayer)
-	delete(deleteMap, configLayer.Digest)
+	layers = append(layers, cfg)
+	delete(deleteMap, cfg.Layer.Digest)
 
 	if err := SaveLayers(layers, fn, false); err != nil {
 		return err
 	}
 
-	var contentLayers []*Layer
-	for _, layer := range layers {
-		contentLayers = append(contentLayers, &layer.Layer)
-		delete(deleteMap, layer.Digest)
-	}
-
+	// Create the manifest
 	fn(api.ProgressResponse{Status: "writing manifest"})
-	if err := CreateManifest(name, configLayer, contentLayers); err != nil {
+	err = CreateManifest(name, cfg, manifestLayers)
+	if err != nil {
 		return err
 	}
 
-	if noprune := os.Getenv("OLLAMA_NOPRUNE"); noprune == "" {
-		if err := deleteUnusedLayers(nil, deleteMap, false); err != nil {
+	if noprune == "" {
+		fn(api.ProgressResponse{Status: "removing any unused layers"})
+		err = deleteUnusedLayers(nil, deleteMap, false)
+		if err != nil {
 			return err
 		}
 	}
@@ -714,7 +739,7 @@ func CopyModel(src, dest string) error {
 	return nil
 }
 
-func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]struct{}, dryRun bool) error {
+func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]bool, dryRun bool) error {
 	fp, err := GetManifestPath()
 	if err != nil {
 		return err
@@ -754,19 +779,21 @@ func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]struct{},
 	}
 
 	// only delete the files which are still in the deleteMap
-	for k := range deleteMap {
-		fp, err := GetBlobsPath(k)
-		if err != nil {
-			log.Printf("couldn't get file path for '%s': %v", k, err)
-			continue
-		}
-		if !dryRun {
-			if err := os.Remove(fp); err != nil {
-				log.Printf("couldn't remove file '%s': %v", fp, err)
+	for k, v := range deleteMap {
+		if v {
+			fp, err := GetBlobsPath(k)
+			if err != nil {
+				log.Printf("couldn't get file path for '%s': %v", k, err)
 				continue
 			}
-		} else {
-			log.Printf("wanted to remove: %s", fp)
+			if !dryRun {
+				if err := os.Remove(fp); err != nil {
+					log.Printf("couldn't remove file '%s': %v", fp, err)
+					continue
+				}
+			} else {
+				log.Printf("wanted to remove: %s", fp)
+			}
 		}
 	}
 
@@ -774,7 +801,7 @@ func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]struct{},
 }
 
 func PruneLayers() error {
-	deleteMap := make(map[string]struct{})
+	deleteMap := make(map[string]bool)
 	p, err := GetBlobsPath("")
 	if err != nil {
 		return err
@@ -791,9 +818,7 @@ func PruneLayers() error {
 		if runtime.GOOS == "windows" {
 			name = strings.ReplaceAll(name, "-", ":")
 		}
-		if strings.HasPrefix(name, "sha256:") {
-			deleteMap[name] = struct{}{}
-		}
+		deleteMap[name] = true
 	}
 
 	log.Printf("total blobs: %d", len(deleteMap))
@@ -848,11 +873,11 @@ func DeleteModel(name string) error {
 		return err
 	}
 
-	deleteMap := make(map[string]struct{})
+	deleteMap := make(map[string]bool)
 	for _, layer := range manifest.Layers {
-		deleteMap[layer.Digest] = struct{}{}
+		deleteMap[layer.Digest] = true
 	}
-	deleteMap[manifest.Config.Digest] = struct{}{}
+	deleteMap[manifest.Config.Digest] = true
 
 	err = deleteUnusedLayers(&mp, deleteMap, false)
 	if err != nil {
@@ -954,9 +979,6 @@ func PushModel(ctx context.Context, name string, regOpts *RegistryOptions, fn fu
 	for _, layer := range layers {
 		if err := uploadBlob(ctx, mp, layer, regOpts, fn); err != nil {
 			log.Printf("error uploading blob: %v", err)
-			if errors.Is(err, errUnauthorized) {
-				return fmt.Errorf("unable to push %s, make sure this namespace exists and you are authorized to push to it", ParseModelPath(name).GetNamespaceRepository())
-			}
 			return err
 		}
 	}
@@ -991,7 +1013,7 @@ func PullModel(ctx context.Context, name string, regOpts *RegistryOptions, fn fu
 	var noprune string
 
 	// build deleteMap to prune unused layers
-	deleteMap := make(map[string]struct{})
+	deleteMap := make(map[string]bool)
 
 	if noprune = os.Getenv("OLLAMA_NOPRUNE"); noprune == "" {
 		manifest, _, err = GetManifest(mp)
@@ -1001,9 +1023,9 @@ func PullModel(ctx context.Context, name string, regOpts *RegistryOptions, fn fu
 
 		if manifest != nil {
 			for _, l := range manifest.Layers {
-				deleteMap[l.Digest] = struct{}{}
+				deleteMap[l.Digest] = true
 			}
-			deleteMap[manifest.Config.Digest] = struct{}{}
+			deleteMap[manifest.Config.Digest] = true
 		}
 	}
 
@@ -1143,10 +1165,7 @@ func GetSHA256Digest(r io.Reader) (string, int64) {
 	return fmt.Sprintf("sha256:%x", h.Sum(nil)), n
 }
 
-var errUnauthorized = fmt.Errorf("unauthorized")
-
 func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.ReadSeeker, regOpts *RegistryOptions) (*http.Response, error) {
-	lastErr := errMaxRetriesExceeded
 	for try := 0; try < maxRetries; try++ {
 		resp, err := makeRequest(ctx, method, requestURL, headers, body, regOpts)
 		if err != nil {
@@ -1167,7 +1186,8 @@ func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.UR
 			if body != nil {
 				body.Seek(0, io.SeekStart)
 			}
-			lastErr = errUnauthorized
+
+			continue
 		case resp.StatusCode == http.StatusNotFound:
 			return nil, os.ErrNotExist
 		case resp.StatusCode >= http.StatusBadRequest:
@@ -1182,7 +1202,7 @@ func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.UR
 		}
 	}
 
-	return nil, lastErr
+	return nil, errMaxRetriesExceeded
 }
 
 func makeRequest(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.Reader, regOpts *RegistryOptions) (*http.Response, error) {

server/routes.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"crypto/sha256"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -27,7 +26,6 @@ import (
 
 	"github.com/jmorganca/ollama/api"
 	"github.com/jmorganca/ollama/llm"
-	"github.com/jmorganca/ollama/parser"
 	"github.com/jmorganca/ollama/version"
 )
 
@@ -411,31 +409,8 @@ func CreateModelHandler(c *gin.Context) {
 		return
 	}
 
-	if req.Name == "" {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "name is required"})
-		return
-	}
-
-	if req.Path == "" && req.Modelfile == "" {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "path or modelfile are required"})
-		return
-	}
-
-	var modelfile io.Reader = strings.NewReader(req.Modelfile)
-	if req.Path != "" && req.Modelfile == "" {
-		bin, err := os.Open(req.Path)
-		if err != nil {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("error reading modelfile: %s", err)})
-			return
-		}
-		defer bin.Close()
-
-		modelfile = bin
-	}
-
-	commands, err := parser.Parse(modelfile)
-	if err != nil {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+	if req.Name == "" || req.Path == "" {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "name and path are required"})
 		return
 	}
 
@@ -449,7 +424,7 @@ func CreateModelHandler(c *gin.Context) {
 		ctx, cancel := context.WithCancel(c.Request.Context())
 		defer cancel()
 
-		if err := CreateModel(ctx, req.Name, commands, fn); err != nil {
+		if err := CreateModel(ctx, req.Name, req.Path, fn); err != nil {
 			ch <- gin.H{"error": err.Error()}
 		}
 	}()
@@ -650,60 +625,6 @@ func CopyModelHandler(c *gin.Context) {
 	}
 }
 
-func HeadBlobHandler(c *gin.Context) {
-	path, err := GetBlobsPath(c.Param("digest"))
-	if err != nil {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	if _, err := os.Stat(path); err != nil {
-		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("blob %q not found", c.Param("digest"))})
-		return
-	}
-
-	c.Status(http.StatusOK)
-}
-
-func CreateBlobHandler(c *gin.Context) {
-	hash := sha256.New()
-	temp, err := os.CreateTemp("", c.Param("digest"))
-	if err != nil {
-		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-	defer temp.Close()
-	defer os.Remove(temp.Name())
-
-	if _, err := io.Copy(temp, io.TeeReader(c.Request.Body, hash)); err != nil {
-		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	if fmt.Sprintf("sha256:%x", hash.Sum(nil)) != c.Param("digest") {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "digest does not match body"})
-		return
-	}
-
-	if err := temp.Close(); err != nil {
-		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	targetPath, err := GetBlobsPath(c.Param("digest"))
-	if err != nil {
-		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	if err := os.Rename(temp.Name(), targetPath); err != nil {
-		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.Status(http.StatusCreated)
-}
-
 var defaultAllowOrigins = []string{
 	"localhost",
 	"127.0.0.1",
@@ -763,8 +684,6 @@ func Serve(ln net.Listener, allowOrigins []string) error {
 	r.POST("/api/copy", CopyModelHandler)
 	r.DELETE("/api/delete", DeleteModelHandler)
 	r.POST("/api/show", ShowModelHandler)
-	r.POST("/api/blobs/:digest", CreateBlobHandler)
-	r.HEAD("/api/blobs/:digest", HeadBlobHandler)
 
 	for _, method := range []string{http.MethodGet, http.MethodHead} {
 		r.Handle(method, "/", func(c *gin.Context) {

server/upload.go

@@ -55,7 +55,7 @@ func (b *blobUpload) Prepare(ctx context.Context, requestURL *url.URL, opts *Reg
 	if b.From != "" {
 		values := requestURL.Query()
 		values.Add("mount", b.Digest)
-		values.Add("from", ParseModelPath(b.From).GetNamespaceRepository())
+		values.Add("from", b.From)
 		requestURL.RawQuery = values.Encode()
 	}
 
@@ -77,14 +77,6 @@ func (b *blobUpload) Prepare(ctx context.Context, requestURL *url.URL, opts *Reg
 
 	b.Total = fi.Size()
 
-	// http.StatusCreated indicates a blob has been mounted
-	// ref: https://distribution.github.io/distribution/spec/api/#cross-repository-blob-mount
-	if resp.StatusCode == http.StatusCreated {
-		b.Completed.Store(b.Total)
-		b.done = true
-		return nil
-	}
-
 	var size = b.Total / numUploadParts
 	switch {
 	case size < minUploadPartSize:
@@ -268,7 +260,7 @@ func (b *blobUpload) uploadChunk(ctx context.Context, method string, requestURL
 			return err
 		}
 
-		return fmt.Errorf("http status %s: %s", resp.Status, body)
+		return fmt.Errorf("http status %d %s: %s", resp.StatusCode, resp.Status, body)
 	}
 
 	if method == http.MethodPatch {