ollama-multirun: this_is_the_toolshed_sh_bash_script_act

Prompt: (raw) (yaml) words:2282 bytes:19499
This is the toolshed.sh Bash script.
Act as an expert Software Engineer.
Do a full code review of this script:

#!/usr/bin/env bash
#
# Ollama Bash Toolshed
#
# Bash scripts to chat with tool using models. Add new tools to your shed with ease. Runs on Ollama.
#
# Usage:
#  ./toolshed.sh
#  ./toolshed.sh modelName

NAME="ollama-bash-toolshed"
VERSION="0.45"
URL="https://github.com/attogram/ollama-bash-toolshed"

DEBUG_MODE="0" # change with: /config verbose [on|off]
TOOLS_DIRECTORY="./tools" # no slash at end
WORKSPACE_DIRECTORY="./workspace" # no slash at end

model=""            # current model
messages=""         # json string of all messages
messageCount=0      # number of messages
request=""          # json string with the latest request to the model
requestCount=0      # number of requests
response=""         # json string with the latest response from the model
availableTools=()   # array of available tools in the shed
toolCount=0         # number of tools in the shed
toolDefinitions=""  # json string with all tool definitions
toolInstructions="" # text list of all tool instructions
toolResult=""       # result of last tool call

configs=(
  'tools:on'    # /config tools [on|off]
  'think:off'   # /config think [on|off]
  'verbose:off' # /config verbose [on|off]
  'api:http://localhost:11434' # /config api [url]  (base Ollama API URL, no slash at end)
)

usage() {
  me=$(basename "$0")
  echo "$NAME"; echo
  echo "Usage:"
  echo "  ./$me [flags]"
  echo "  ./$me [model]"
  echo; echo "Flags:";
  echo "  -h      -- Help for $NAME"
  echo "  -v      -- Show version information"
  echo "  [model] -- Set the model"
}

getHelp() {
    cat << EOF
Model Commands:
  /list            - List models
  /ps              - List running models
  /pull modelName  - Pull new model
  /run modelName   - Run a model
  /show            - Current model info
  /show modelName  - Model info
  /stop modelName  - Stop a running model

Tool Commands:
  /tools           - list tools available
  /tool toolName   - show tool definition
  /instructions    - list instructions for all tools
  /exec toolName param1="value" param2="value" - run a tool, with optional parameters

System Commands:
  /multi             - enter multi-line prompt
  /messages          - list of current messages
  /messages save     - save messages to a file.  Optional <file> to specify file. Must be in ./workspace directory.
  /messages load     - load messages from a file. Optional <file> to specify file. Must be in ./workspace directory.
  /messages append   - append to current messages list from a file. Optional <file> to specify file. Must be in ./workspace directory.
  /system            - show system prompt
  /clear             - clear the message and model cache
  /config            - view all configs (tools, think, verbose)
  /config name       - view a config
  /config name value - set a config to new value
  /quit or /bye      - end the chat
  !<command>         - run any command in the local shell
  /help              - list of all commands
EOF
}

getSystemPromptIdentity() {
  echo "You are an AI assistant."
  echo "You are inside the Ollama Bash Toolshed."
  echo "You are running on the Ollama application.
"
}

getSystemPromptTerminal() {
  echo "Your response is rendered in a text terminal.
- You may use ANSI escape codes to color your response.
- COLOR    FOREGROUND      BACKGROUND
  red      \`\\033[31m\`   \`\\033[41m\`
  green    \`\\033[32m\`   \`\\033[42m\`
  yellow   \`\\033[33m\`   \`\\033[43m\`
  blue     \`\\033[34m\`   \`\\033[44m\`
  magenta  \`\\033[35m\`   \`\\033[45m\`
  cyan     \`\\033[36m\`   \`\\033[46m\`
  black    \`\\033[30m\`   \`\\033[40m\`
  white    \`\\033[37m\`   \`\\033[47m\`
- To reset text to default colors: \`\\033[0m\`
"
}

getSystemPromptUserCommands() {
  echo "You can assist with commands the user may use inside Ollama Bash Toolshed.
- Only the user may use these commands.
- Command list:

$(getHelp)
"
}

getSystemPrompt() {
  getSystemPromptIdentity
}

setColorScheme() {
  LOGO=$'\033[36m\033[40m' # cyan on black
  PROMPT=$'\033[34m\033[40m' # blue on black
  THINKING=$'\e[38;5;241m'$'\e[48;5;0m' # grey on black
  RESET=$'\033[0m' # reset terminal colors
  ERASE_LINE=$'\e[2K'$'\e[A'
}

debug() {
  if [ "$DEBUG_MODE" == "1" ]; then
    echo -e "[DEBUG] $1"
  fi
}

debugJson() {
  if [ "$DEBUG_MODE" == "1" ]; then
    echo "$1" | jq -r '.' 2>/dev/null
  fi
}

getTools() {
  availableTools=()
  toolDefinitions=""
  toolInstructions=""
  toolCount=0
  if [[ "$toolsConfig" != "on" ]]; then
    return
  fi
  local toolDir
  local toolName
  availableTools=()
  for toolDir in $TOOLS_DIRECTORY/*/; do
    if [ -d "${toolDir}" ]; then
      toolName=$(basename "${toolDir}")
      local definitionFile="${toolDir}/definition.json"
      if [ -f "${definitionFile}" ]; then
        if [ -n "$toolDefinitions" ]; then
          toolDefinitions+=","
        fi
        toolDefinitions+="$(cat "$definitionFile")"
        availableTools+=("$toolName")
      fi
      local instructionFile="${toolDir}/instructions.txt"
      if [ -f "${instructionFile}" ]; then
        if [ -n "$toolInstructions" ]; then
          toolInstructions+=$'\n'
        fi
        toolInstructions+="$(cat "$instructionFile")"
      fi
      ((toolCount++))
    fi
  done
}

getConfig() {
  local configName="$1"
  for config in "${configs[@]}"; do
    if [[ "${config%%:*}" == "$configName" ]]; then
      echo "${config#*:}"
      break
    fi
  done
}

setConfigs() {
  for config in "${configs[@]}"; do
    name="${config%%:*}"
    value="${config#*:}"
    # set $nameConfig to $value
    eval ${name}Config=\$value
    case $name in
      tools)
        getTools
        # TODO - redo systemPrompt with new tool setting
        ;;
      verbose)
        if [[ "$value" == "on" ]]; then
          DEBUG_MODE=1
        else
          DEBUG_MODE=0
        fi
        ;;
    esac
  done
}

setConfig() {
  local configName="$1"
  local configValue="$2"
  local newConfigs=()
  for config in "${configs[@]}"; do
    name="${config%%:*}"
    value="${config#*:}"
    if [[ "$name" == "$configName" ]]; then
      value=${commandArray[2]}
      echo "$name: $value"
    fi
    # set var $nameConfig to $value
    eval ${name}Config=\$value
    newConfigs+=("$name:$value")
  done
  configs=("${newConfigs[@]}")
  setConfigs
}

safeJson() {
  jq -Rn --arg str "$1" '$str'
}

addMessage() {
  local role="$1"
  local message="$2"
  local toolName="$3"
  newMessage="{\"role\":\"$role\""
  if [ -n "$toolName" ]; then
    newMessage+=",\"tool_name\":\"$toolName\""
  fi
  newMessage+=",\"content\":$(safeJson "$message")}"
  if [ -n "$messages" ]; then
    messages+=","
  fi
  messages+="$newMessage"
  ((messageCount++))
  debug "addMessage #$messageCount: role:$role"
}

addMessageAssistantToolCall() {
  local response="$1"
  local tool_calls="$(echo "$response" | jq -r '.message.tool_calls')"
  local message="{\"role\":\"assistant\", \"tool_calls\": $tool_calls}"
  if [ -n "$messages" ]; then
    messages+=","
  fi
  messages+="$message"
  ((messageCount++))
}

createRequest() {
    echo "{\"model\": \"$model\", \"messages\": [ ${messages} ], \"stream\": false"
    if [ "$thinkConfig" == "on" ]; then
      echo ", \"think\": true"
    fi
    if [ "$toolsConfig" == "on" ]; then
      echo ", \"tools\": [ ${toolDefinitions} ]"
    fi
    echo "}"
}

sendRequestToAPI() {
  if [ -z "$apiConfig" ]; then
    echo "ERROR: API URL is not set. Use /config api [url] to set it." >&2
    return 1
  fi
  echo "$(createRequest)" | curl -s -X POST "${apiConfig}/api/chat" -H 'Content-Type: application/json' -d @-
}

sendRequest() {
  debug "request:"
  debugJson "$(createRequest)"
  ((requestCount++))
  debug "sendRequestToAPI"
  echo -n "⏳ Waiting for model response ..."
  response=$(sendRequestToAPI)
  echo -e "$ERASE_LINE"
  debug "response:"
  debugJson "$response"
}

clear() {
  echo "Clearing messages"
  messages=""
  messageCount=0
  requestCount=0
  addMessage "system" "$(getSystemPrompt)"
  if [ -z "$model" ]; then
    return
  fi
  echo "Clearing model: $model"
  (
    expect \
    -c "spawn ollama run $model" \
    -c "expect \">>> \"" \
    -c 'send -- "/clear\n"' \
    -c "expect \"Cleared session context\"" \
    -c 'send -- "/bye\n"' \
    -c "expect eof" \
    ;
  ) # > /dev/null 2>&1 # Suppress output
  if [ $? -ne 0 ]; then
    echo "ERROR: Failed to clear model session: $model" >&2
  fi
}

processErrors() {
  if echo "$response" | jq -e '.error' >/dev/null; then # Check for errors
    echo "$response" | jq -r '.error' 2>/dev/null
    return 1
  fi
  return 0 # no errors
}

runTool() {
  toolName="$1"
  toolArgs="$2"
  echo "[TOOL] call: $toolName: $toolArgs"
  set -o noglob # turn off glob - do not expand *
  toolResult="$($TOOLS_DIRECTORY/${toolName}/run.sh ${toolArgs})"
  set +o noglob # turn on glob
  echo -n "[TOOL] result: $(echo "$toolResult" | wc -w | sed 's/ //g') words, $(echo "$toolResult" | wc -c | sed 's/ //g') chars, $(echo "$toolResult" | wc -l | sed 's/ //g') lines"
  echo ", 1st line: $(echo "$toolResult" | head -1)"; echo
}

processToolCall() {
  if echo "$response" | jq -e '.message.tool_calls' >/dev/null; then # Check if response contains tool_calls
    showThinking
    local responseMessageContent=$(echo "$response" | jq -r '.message.content' 2>/dev/null)
    if [ -n "$responseMessageContent" ]; then
      echo "$responseMessageContent"
    fi
    local tool_calls=$(echo "$response" | jq -r '.message.tool_calls[]' 2>/dev/null) # get all tool calls
    while IFS= read -r tool_call; do # Process each tool call
      local function=$(echo "$tool_call" | jq -r '.function' 2>/dev/null)
      local function_name=$(echo "$tool_call" | jq -r '.function.name' 2>/dev/null)
      local function_arguments=$(echo "$tool_call" | jq -r '.function.arguments' 2>/dev/null)
      debug "processToolCall: Calling function: $function_name"
      if [[ " ${availableTools[*]} " =~ " ${function_name} " ]]; then # If tool is defined
        runTool "$function_name" "$function_arguments"
      else
        debug "processToolCall: Unknown function: $function_name"
        continue
      fi
      addMessageAssistantToolCall "$response"
      addMessage "tool" "$toolResult" "${function_name}" # Add tool response to messages
      sendRequest
      processToolCall
    done < <(echo "$tool_calls" | jq -c '.')
  fi
}

userRunTool() {
  local tool="$1"
  local parameters="$2"
  local paramNames=()
  local paramValues=()
  local parametersJson=""
  # for every param="value" (or param=value) pair
  while [[ $parameters =~ ([^[:space:]=]+)=((\"[^\"]*\")|([^[:space:]]+)) ]]; do
    key="${BASH_REMATCH[1]}"
    val="${BASH_REMATCH[2]}"
    val="${val%\"}" # remove quotes
    val="${val#\"}"
    paramNames+=("$key")
    paramValues+=("$val")
    parameters="${parameters#*"${BASH_REMATCH[0]}"}" # trim off processed part
  done
  for i in "${!paramNames[@]}"; do
    if [ -n "$parametersJson" ]; then
      parametersJson+=","
    fi
    parametersJson+="\"${paramNames[$i]}\":\"${paramValues[$i]}\""
  done
  runTool "$tool" "{$parametersJson}"
  echo; echo "$toolResult"
}

fileIsInWorkspace() {
  case "$(realpath "$(dirname "$1")")" in
    "$(realpath "${WORKSPACE_DIRECTORY}")"*)
      return 0 # File is inside workspace
      ;;
    *)
      return 1 # File is not inside workspace
      ;;
  esac
}

processUserCommandMessages() {
  local action="${commandArray[1]}"
  local file="${commandArray[2]}"
  if [ -z "$action" ]; then # /messages = list all messages
    echo "{\"messages\":[${messages}]}" | jq -r '.messages' # 2>/dev/null # list all messages
    return 0
  fi
  if [ -z "$file" ]; then  # if no file specified, then use default messages filename
    file="${WORKSPACE_DIRECTORY}/messages.json"
  fi
  fileIsInWorkspace "$file"
  if [[ $? = 1 ]]; then
    echo "Error: file must be inside the workspace: ${WORKSPACE_DIRECTORY}"
    return
  fi
  if [[ "${action}" == "save" ]]; then
    echo "${messages}" > "$file"
    echo "Saved messages to: $file"
    echo "$(ls -al "$file")"
    return 0
  fi
  if [ ! -f "$file" ]; then
      echo "Error: File not found"
      return 0
  fi
  local load="$(cat "$file")"
  # TODO - validate load is valid json -- cat file.txt | jq empty
  case "${action}" in
    load)
      messages="$load"
      echo "Loaded messages from: $file"
      ;;
    append)
      messages+=",$load"
      echo "Appended to messages from: $file"
      ;;
    *)
      echo "Error: unknown messages action"
      ;;
  esac
}

processUserCommandConfig() {
  if [ -n "${commandArray[2]}" ]; then # set a config
    setConfig "${commandArray[1]}" "${commandArray[2]}"
    return 0
  fi
  if [ -n "${commandArray[1]}" ]; then # list a config
    echo -n "${commandArray[1]}: "
    getConfig "${commandArray[1]}"
    return 0
  fi
  for config in "${configs[@]}"; do # list all configs
    echo "${config%%:*}: ${config#*:}"
  done
}

processUserCommand() {
  firstChar=${prompt:0:1}
  if [ "$firstChar" = "!" ]; then # do any shell command
    eval "${prompt#*!}"
    return 0
  fi
  if [ "$firstChar" != "/" ]; then
    return 1 # no user command was processed
  fi
  IFS=' ' read -r -a commandArray <<< "$prompt"
  case ${commandArray[0]} in
    /clear)
      clear
      ;;
    /config|/configs|/set)
      processUserCommandConfig
      ;;
    /exec)
      local tool="${commandArray[1]}"
      if [[ " ${availableTools[*]} " =~ " ${tool} " ]]; then # If tool is defined
        userRunTool "$tool" "${commandArray[*]:2}"
        return 0
      fi
      echo "Error: Tool not in the shed"
      ;;
    /help)
      getHelp
      ;;
    /instructions)
      echo "$toolInstructions"
      ;;
    /list|/models)
      ollama list
      ;;
    /messages|/msgs)
      processUserCommandMessages
      ;;
    /multi)
      echo "Multi line input mode. Press Ctrl+D on a new line when finished."
      echo "---"
      local multiLinePrompt=$(cat)
      echo "---"
      chat "$multiLinePrompt"
      ;;
    /ps)
      ollama ps
      ;;
    /pull)
      if [ -z "${commandArray[1]}" ]; then
        echo "Error: no model specified"
        return 0
      fi
      ollama pull "${commandArray[1]}"
      ;;
    /quit|/bye)
      echo "Closing the Ollama Bash Toolshed. Bye!"; echo
      exit
      ;;
    /run|/load)
      local newModel="${commandArray[1]}"
      if [ -z "$newModel" ]; then
        echo "Error: no model specified"
        return 0
      fi
      echo "Loading model: $newModel"
      model="$newModel"
      ;;
    /show)
      if [ -z "${commandArray[1]}" ]; then
        ollama show "$model"
        return 0
      fi
      ollama show "${commandArray[1]}"
      ;;
    /stop)
      if [ -z "${commandArray[1]}" ]; then
        echo "Error: no model specified"
        return 0
      fi
      ollama stop "${commandArray[1]}"
      ;;
    /system)
      getSystemPrompt
      ;;
    /tool)
      if [ -z "${commandArray[1]}" ]; then
        echo "Error: no tool specified"
        return 0
      fi
      local definitionFile="$TOOLS_DIRECTORY/${commandArray[1]}/definition.json"
      if ! [ -f "$definitionFile" ]; then
        echo "Error: tool does not exist"
        return 0
      fi
      cat "$definitionFile" | jq -r '.' 2>/dev/null
      ;;
    /tools)
      echo "${availableTools[*]}"
      ;;
    *)
      echo "Unknown command: ${commandArray[0]}"
      ;;
  esac
  return 0 # processed user command
}

showThinking() {
  if [[ "$thinkConfig" != "on" ]]; then
    return
  fi
  local responseMessageThinking=$(echo "$response" | jq -r '.message.thinking' 2>/dev/null)
  if [ -n "$responseMessageThinking" ]; then
    echo "${THINKING}🤔💭 $responseMessageThinking 💭🤔${RESET}"; echo
  fi
}

chat() {
  local prompt="$1"
  processUserCommand
  if [[ $? = 0 ]]; then # If a user command was processed
    return
  fi
  if [ -z "$model" ]; then
    echo "Error: no model running.  Use '/run modelName' to load a model. Use '/list' to get available models."
    return
  fi
  addMessage "user" "$prompt"
  sendRequest
  processErrors
  if [[ $? = 1 ]]; then # If there was an error
    return
  fi
  processToolCall
  showThinking
  responseMessageContent="$(echo "$response" | jq -r '.message.content' 2>/dev/null)"
  addMessage "assistant" "$responseMessageContent"
  echo -e "$responseMessageContent"
}

checkRequirements() {
  local requirements=(
    "ollama"   # core
    "basename" # core
    "curl"     # core, getWebPageHtml
    "jq"       # core, tools
    "expect"   # core
    "sed"      # core
    "head"     # core
    "wc"       # core
    "bc"       # core, calculator
    "date"     # getDateTime
    "man"      # getManualPageForCommand
    "lynx"     # getWebPageText
  )
  for requirement in "${requirements[@]}"; do
    check=$(command -v $requirement 2> /dev/null)
    if [ -z "$(command -v $requirement 2> /dev/null)" ]; then
      echo "Requirement ERROR: Requirement not installed: $requirement"
    else 
      debug "Requirement OK: $requirement"
    fi
  done
}

parseCommandLine() {
  model=""
  while (( "$#" )); do
    case "$1" in
      -h) # help
        usage
        exit 0
        ;;
      -v) # version
        echo "$NAME v$VERSION"
        exit 0
        ;;
      -*|--*=) # unsupported flags
        echo "Error: unsupported argument: $1" >&2
        exit 1
        ;;
      *) # preserve positional arguments
        model+="$1"
        shift
        ;;
    esac
  done
  # set positional arguments in their proper place
  eval set -- "${model}"
}

parseCommandLine "$@"
setConfigs
setColorScheme
echo "${LOGO}
 ███████████                   ████          █████                   █████
░█░░░███░░░█                  ░░███         ░░███                   ░░███
░   ░███  ░   ██████   ██████  ░███   █████  ░███████    ██████   ███████
    ░███     ███░░███ ███░░███ ░███  ███░░   ░███░░███  ███░░███ ███░░███
    ░███    ░███ ░███░███ ░███ ░███ ░░█████  ░███ ░███ ░███████ ░███ ░███
    ░███    ░███ ░███░███ ░███ ░███  ░░░░███ ░███ ░███ ░███░░░  ░███ ░███
    █████   ░░██████ ░░██████  █████ ██████  ████ █████░░██████ ░░████████
   ░░░░░     ░░░░░░   ░░░░░░  ░░░░░ ░░░░░░  ░░░░ ░░░░░  ░░░░░░   ░░░░░░░░

${NAME} v${VERSION}${RESET}"
checkRequirements
addMessage "system" "$(getSystemPrompt)"
if [ -z "$model" ]; then
  echo; echo "⚠️  No model loaded - /list to view available models, /run modelName to load a model"
fi
echo; echo "/help for commands. /quit or Ctrl+C to exit."
while true; do
    echo; echo -n "${PROMPT}${NAME} (${model:-no model})"
    echo -n " ($toolCount tools) [$requestCount requests] [$messageCount messages]"
    echo; echo -n ">>>${RESET} "
    read -r prompt
    echo
    chat "$prompt"
done
Model	Response words	Response bytes	Total duration	Load duration	Prompt eval count	Prompt eval duration	Prompt eval rate	Eval count	Eval duration	Eval rate	Model params	Model size	Model context	Ollama context	Ollama proc
deepseek-r1:14b	550	3876	6m42.5890077s	6.036482s	5611 token(s)	13.8057302s	406.43 tokens/s	2046 token(s)	6m22.7452058s	5.35 tokens/s	14.8B	14 GB	131072	16384	48%/52% CPU/GPU
deepseek-r1:8b	464	3311	4m27.3359266s	3.0243522s	5610 token(s)	6.2156452s	902.56 tokens/s	3147 token(s)	4m18.0954259s	12.19 tokens/s	8.2B	9.6 GB	131072	16384	21%/79% CPU/GPU
dolphin3:8b	280	2028	28.0385688s	3.0514223s	5562 token(s)	5.0737847s	1096.22 tokens/s	400 token(s)	19.9122877s	20.09 tokens/s	8.0B	8.7 GB	131072	16384	15%/85% CPU/GPU
gemma3n:e4b	880	6722	1m50.0457501s	4.2863846s	6553 token(s)	31.1449342s	210.40 tokens/s	1498 token(s)	1m14.6127645s	20.08 tokens/s	6.9B	8.5 GB	32768	16384	11%/89% CPU/GPU
mistral:7b	348	2147	30.2346676s	2.3834434s	6618 token(s)	6.3345471s	1044.75 tokens/s	482 token(s)	21.5156407s	22.40 tokens/s	7.2B	8.3 GB	32768	16384	11%/89% CPU/GPU
qwen2.5vl:7b	6	45									8.3B	10 GB	128000	16384	34%/66% CPU/GPU
qwen3:8b	685	4799	3m45.43103s	3.2602417s	5618 token(s)	5.9189865s	949.15 tokens/s	2708 token(s)	3m36.2512983s	12.52 tokens/s	8.2B	9.6 GB	40960	16384	21%/79% CPU/GPU
System
Ollama proc	21%/79% CPU/GPU
Ollama context	16384
Ollama version	0.10.0-rc0
Multirun timeout	1200 seconds
Sys arch	x86_64
Sys processor	unknown
sys memory	11G + 19G
Sys OS	CYGWIN_NT-10.0-22631 3.6.4-1.x86_64